[−][src]Trait bolero::generator::ValueGenerator
Generate a value with a parameterized generator
Associated Types
type Output
Required methods
Loading content...Provided methods
fn map<F, T>(self, map: F) -> MapGenerator<Self, F> where
F: Fn(Self::Output) -> T,
F: Fn(Self::Output) -> T,
Map the value of a generator
fn map_gen<F, T>(self, map: F) -> MapGenerator<Self, F> where
F: Fn(Self::Output) -> T,
F: Fn(Self::Output) -> T,
Map the value of a generator, exists to reduce conflicts with
other map
functions.
fn and_then<F, T>(self, and_then: F) -> AndThenGenerator<Self, F> where
F: Fn(Self::Output) -> T,
T: ValueGenerator,
F: Fn(Self::Output) -> T,
T: ValueGenerator,
Map the value of a generator with a new generator
fn and_then_gen<F, T>(self, and_then: F) -> AndThenGenerator<Self, F> where
F: Fn(Self::Output) -> T,
T: ValueGenerator,
F: Fn(Self::Output) -> T,
T: ValueGenerator,
Map the value of a generator with a new generator, exists to
reduce conflicts with other map
functions.
fn filter<F>(self, filter: F) -> FilterGenerator<Self, F> where
F: Fn(&Self::Output) -> bool,
F: Fn(&Self::Output) -> bool,
Filter the value of a generator
fn filter_gen<F>(self, filter: F) -> FilterGenerator<Self, F> where
F: Fn(&Self::Output) -> bool,
F: Fn(&Self::Output) -> bool,
Filter the value of a generator, exists to
reduce conflicts with other filter
functions.
fn filter_map<F, T>(self, filter_map: F) -> FilterMapGenerator<Self, F> where
F: Fn(Self::Output) -> Option<T>,
F: Fn(Self::Output) -> Option<T>,
Filter the value of a generator and map it to something else
fn filter_map_gen<F, T>(self, filter_map: F) -> FilterMapGenerator<Self, F> where
F: Fn(Self::Output) -> Option<T>,
F: Fn(Self::Output) -> Option<T>,
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<G> ValueGenerator for [G; 22] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 22]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 22] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 22] as ValueGenerator>::Output> where
D_: Driver,
impl<I, A, B, C, D, E, F, G, H> ValueGenerator for (A, B, C, D, E, F, G, H, I) where
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
E: ValueGenerator,
F: ValueGenerator,
G: ValueGenerator,
H: ValueGenerator,
I: ValueGenerator,
[src]
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
E: ValueGenerator,
F: ValueGenerator,
G: ValueGenerator,
H: ValueGenerator,
I: ValueGenerator,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I) as ValueGenerator>::Output> where
D_: Driver,
impl<E, A, B, C, D> ValueGenerator for (A, B, C, D, E) where
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
E: ValueGenerator,
[src]
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
E: ValueGenerator,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E) as ValueGenerator>::Output> where
D_: Driver,
impl ValueGenerator for i8
[src]
impl<G> ValueGenerator for [G; 21] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 21]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 21] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 21] as ValueGenerator>::Output> where
D_: Driver,
impl ValueGenerator for char
[src]
impl<Ok, Err, Selector> ValueGenerator for ResultGenerator<Ok, Err, Selector> where
Err: ValueGenerator,
Ok: ValueGenerator,
Selector: ValueGenerator<Output = bool>,
[src]
Err: ValueGenerator,
Ok: ValueGenerator,
Selector: ValueGenerator<Output = bool>,
type Output = Result<<Ok as ValueGenerator>::Output, <Err as ValueGenerator>::Output>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<ResultGenerator<Ok, Err, Selector> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<ResultGenerator<Ok, Err, Selector> as ValueGenerator>::Output> where
D: Driver,
impl<K, V, L, Len> ValueGenerator for HashMapGenerator<K, V, L> where
K: ValueGenerator,
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
V: ValueGenerator,
<K as ValueGenerator>::Output: Sized,
<K as ValueGenerator>::Output: Hash,
<K as ValueGenerator>::Output: Eq,
[src]
K: ValueGenerator,
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
V: ValueGenerator,
<K as ValueGenerator>::Output: Sized,
<K as ValueGenerator>::Output: Hash,
<K as ValueGenerator>::Output: Eq,
type Output = HashMap<<K as ValueGenerator>::Output, <V as ValueGenerator>::Output, RandomState>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<HashMapGenerator<K, V, L> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<HashMapGenerator<K, V, L> as ValueGenerator>::Output> where
D: Driver,
impl<Left, Right, Selector> ValueGenerator for EitherGenerator<Left, Right, Selector> where
Left: ValueGenerator,
Right: ValueGenerator,
Selector: ValueGenerator<Output = bool>,
[src]
Left: ValueGenerator,
Right: ValueGenerator,
Selector: ValueGenerator<Output = bool>,
type Output = Either<<Left as ValueGenerator>::Output, <Right as ValueGenerator>::Output>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<EitherGenerator<Left, Right, Selector> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<EitherGenerator<Left, Right, Selector> as ValueGenerator>::Output> where
D: Driver,
impl<T> ValueGenerator for Range<T> where
T: BoundedValue<Range<T>> + TypeGenerator,
[src]
T: BoundedValue<Range<T>> + TypeGenerator,
type Output = T
fn generate<D>(
&self,
driver: &mut D
) -> Option<<Range<T> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<Range<T> as ValueGenerator>::Output> where
D: Driver,
impl ValueGenerator for u8
[src]
impl<G> ValueGenerator for [G; 15] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 15]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 15] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 15] as ValueGenerator>::Output> where
D_: Driver,
impl ValueGenerator for BooleanGenerator
[src]
type Output = bool
fn generate<D>(
&self,
driver: &mut D
) -> Option<<BooleanGenerator as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<BooleanGenerator as ValueGenerator>::Output> where
D: Driver,
impl<O> ValueGenerator for OneOf<O> where
O: OneOfGenerator,
[src]
O: OneOfGenerator,
type Output = <O as OneOfGenerator>::Output
fn generate<R>(
&self,
driver: &mut R
) -> Option<<OneOf<O> as ValueGenerator>::Output> where
R: Driver,
[src]
&self,
driver: &mut R
) -> Option<<OneOf<O> as ValueGenerator>::Output> where
R: Driver,
impl<V, L, Len> ValueGenerator for BTreeSetGenerator<V, L> where
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
V: ValueGenerator,
<V as ValueGenerator>::Output: Sized,
<V as ValueGenerator>::Output: Ord,
[src]
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
V: ValueGenerator,
<V as ValueGenerator>::Output: Sized,
<V as ValueGenerator>::Output: Ord,
type Output = BTreeSet<<V as ValueGenerator>::Output>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<BTreeSetGenerator<V, L> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<BTreeSetGenerator<V, L> as ValueGenerator>::Output> where
D: Driver,
impl<G> ValueGenerator for [G; 4] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 4]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 4] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 4] as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 18] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 18]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 18] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 18] as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 23] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 23]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 23] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 23] as ValueGenerator>::Output> where
D_: Driver,
impl ValueGenerator for f64
[src]
impl<G> ValueGenerator for [G; 1] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 1]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 1] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 1] as ValueGenerator>::Output> where
D_: Driver,
impl<K, V, L, Len> ValueGenerator for BTreeMapGenerator<K, V, L> where
K: ValueGenerator,
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
V: ValueGenerator,
<K as ValueGenerator>::Output: Sized,
<K as ValueGenerator>::Output: Ord,
[src]
K: ValueGenerator,
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
V: ValueGenerator,
<K as ValueGenerator>::Output: Sized,
<K as ValueGenerator>::Output: Ord,
type Output = BTreeMap<<K as ValueGenerator>::Output, <V as ValueGenerator>::Output>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<BTreeMapGenerator<K, V, L> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<BTreeMapGenerator<K, V, L> as ValueGenerator>::Output> where
D: Driver,
impl<AC, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB> 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) where
A: ValueGenerator,
AA: ValueGenerator,
AB: ValueGenerator,
AC: 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,
[src]
A: ValueGenerator,
AA: ValueGenerator,
AB: ValueGenerator,
AC: 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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output, <AA as ValueGenerator>::Output, <AB as ValueGenerator>::Output, <AC as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC) as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 28] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 28]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 28] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 28] as ValueGenerator>::Output> where
D_: Driver,
impl<AE, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD> 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) where
A: ValueGenerator,
AA: ValueGenerator,
AB: ValueGenerator,
AC: ValueGenerator,
AD: ValueGenerator,
AE: 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,
[src]
A: ValueGenerator,
AA: ValueGenerator,
AB: ValueGenerator,
AC: ValueGenerator,
AD: ValueGenerator,
AE: 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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output, <AA as ValueGenerator>::Output, <AB as ValueGenerator>::Output, <AC as ValueGenerator>::Output, <AD as ValueGenerator>::Output, <AE as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE) as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 33] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 33]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 33] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 33] as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 25] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 25]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 25] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 25] as ValueGenerator>::Output> where
D_: Driver,
impl<AG, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF> 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) where
A: ValueGenerator,
AA: ValueGenerator,
AB: ValueGenerator,
AC: ValueGenerator,
AD: ValueGenerator,
AE: ValueGenerator,
AF: ValueGenerator,
AG: 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,
[src]
A: ValueGenerator,
AA: ValueGenerator,
AB: ValueGenerator,
AC: ValueGenerator,
AD: ValueGenerator,
AE: ValueGenerator,
AF: ValueGenerator,
AG: 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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output, <AA as ValueGenerator>::Output, <AB as ValueGenerator>::Output, <AC as ValueGenerator>::Output, <AD as ValueGenerator>::Output, <AE as ValueGenerator>::Output, <AF as ValueGenerator>::Output, <AG as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG) as ValueGenerator>::Output> where
D_: Driver,
impl<AA, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> 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) where
A: ValueGenerator,
AA: 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,
[src]
A: ValueGenerator,
AA: 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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output, <AA as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA) as ValueGenerator>::Output> where
D_: Driver,
impl ValueGenerator for String
[src]
impl<V> ValueGenerator for Vec<V> where
V: ValueGenerator,
[src]
V: ValueGenerator,
type Output = Vec<<V as ValueGenerator>::Output>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<Vec<V> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<Vec<V> as ValueGenerator>::Output> where
D: Driver,
impl ValueGenerator for ()
[src]
impl<G> ValueGenerator for [G; 27] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 27]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 27] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 27] as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 8] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 8]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 8] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 8] as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 11] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 11]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 11] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 11] as ValueGenerator>::Output> where
D_: Driver,
impl<T, G, B> ValueGenerator for BoundedGenerator<G, B> where
B: RangeBounds<<T as BoundedValue<B>>::BoundValue>,
G: ValueGenerator<Output = T>,
T: BoundedValue<B>,
[src]
B: RangeBounds<<T as BoundedValue<B>>::BoundValue>,
G: ValueGenerator<Output = T>,
T: BoundedValue<B>,
impl<V, K> ValueGenerator for BTreeMap<K, V> where
K: ValueGenerator,
V: ValueGenerator,
<K as ValueGenerator>::Output: Sized,
<K as ValueGenerator>::Output: Ord,
[src]
K: ValueGenerator,
V: ValueGenerator,
<K as ValueGenerator>::Output: Sized,
<K as ValueGenerator>::Output: Ord,
type Output = BTreeMap<<K as ValueGenerator>::Output, <V as ValueGenerator>::Output>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<BTreeMap<K, V> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<BTreeMap<K, V> as ValueGenerator>::Output> where
D: Driver,
impl<D, A, B, C> ValueGenerator for (A, B, C, D) where
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
[src]
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D) as ValueGenerator>::Output> where
D_: Driver,
impl<V> ValueGenerator for BTreeSet<V> where
V: ValueGenerator,
<V as ValueGenerator>::Output: Sized,
<V as ValueGenerator>::Output: Ord,
[src]
V: ValueGenerator,
<V as ValueGenerator>::Output: Sized,
<V as ValueGenerator>::Output: Ord,
type Output = BTreeSet<<V as ValueGenerator>::Output>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<BTreeSet<V> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<BTreeSet<V> as ValueGenerator>::Output> where
D: Driver,
impl<V> ValueGenerator for BinaryHeap<V> where
V: ValueGenerator,
<V as ValueGenerator>::Output: Sized,
<V as ValueGenerator>::Output: Ord,
[src]
V: ValueGenerator,
<V as ValueGenerator>::Output: Sized,
<V as ValueGenerator>::Output: Ord,
type Output = BinaryHeap<<V as ValueGenerator>::Output>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<BinaryHeap<V> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<BinaryHeap<V> as ValueGenerator>::Output> where
D: Driver,
impl<T> ValueGenerator for TypeValueGenerator<T> where
T: TypeGenerator,
[src]
T: TypeGenerator,
type Output = T
fn generate<R>(
&self,
driver: &mut R
) -> Option<<TypeValueGenerator<T> as ValueGenerator>::Output> where
R: Driver,
[src]
&self,
driver: &mut R
) -> Option<<TypeValueGenerator<T> as ValueGenerator>::Output> where
R: Driver,
impl<G> ValueGenerator for [G; 10] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 10]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 10] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 10] as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 13] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 13]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 13] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 13] as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 30] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 30]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 30] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 30] as ValueGenerator>::Output> where
D_: Driver,
impl<T> ValueGenerator for [T; 0]
[src]
type Output = [T; 0]
fn generate<D_>(
&self,
_driver: &mut D_
) -> Option<<[T; 0] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
_driver: &mut D_
) -> Option<<[T; 0] as ValueGenerator>::Output> where
D_: Driver,
impl ValueGenerator for isize
[src]
impl<V> ValueGenerator for VecDeque<V> where
V: ValueGenerator,
[src]
V: ValueGenerator,
type Output = VecDeque<<V as ValueGenerator>::Output>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<VecDeque<V> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<VecDeque<V> as ValueGenerator>::Output> where
D: Driver,
impl<H, A, B, C, D, E, F, G> ValueGenerator for (A, B, C, D, E, F, G, H) where
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
E: ValueGenerator,
F: ValueGenerator,
G: ValueGenerator,
H: ValueGenerator,
[src]
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
E: ValueGenerator,
F: ValueGenerator,
G: ValueGenerator,
H: ValueGenerator,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H) as ValueGenerator>::Output> where
D_: Driver,
impl<T> ValueGenerator for PhantomData<T>
[src]
type Output = PhantomData<T>
fn generate<R>(
&self,
_driver: &mut R
) -> Option<<PhantomData<T> as ValueGenerator>::Output> where
R: Driver,
[src]
&self,
_driver: &mut R
) -> Option<<PhantomData<T> as ValueGenerator>::Output> where
R: Driver,
impl<T> ValueGenerator for Constant<T> where
T: Clone,
[src]
T: Clone,
type Output = T
fn generate<R>(
&self,
_driver: &mut R
) -> Option<<Constant<T> as ValueGenerator>::Output> where
R: Driver,
[src]
&self,
_driver: &mut R
) -> Option<<Constant<T> as ValueGenerator>::Output> where
R: Driver,
impl<T> ValueGenerator for RangeFrom<T> where
T: BoundedValue<RangeFrom<T>> + TypeGenerator,
[src]
T: BoundedValue<RangeFrom<T>> + TypeGenerator,
type Output = T
fn generate<D>(
&self,
driver: &mut D
) -> Option<<RangeFrom<T> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<RangeFrom<T> as ValueGenerator>::Output> where
D: Driver,
impl<G, H, F> ValueGenerator for AndThenGenerator<G, F> where
F: Fn(<G as ValueGenerator>::Output) -> H,
G: ValueGenerator,
H: ValueGenerator,
[src]
F: Fn(<G as ValueGenerator>::Output) -> H,
G: ValueGenerator,
H: ValueGenerator,
type Output = <H as ValueGenerator>::Output
fn generate<D>(
&self,
driver: &mut D
) -> Option<<AndThenGenerator<G, F> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<AndThenGenerator<G, F> as ValueGenerator>::Output> where
D: Driver,
impl ValueGenerator for u32
[src]
impl<Start, End, T> ValueGenerator for RangeInclusiveGenerator<Start, End> where
End: ValueGenerator<Output = T>,
Start: ValueGenerator<Output = T>,
[src]
End: ValueGenerator<Output = T>,
Start: ValueGenerator<Output = T>,
type Output = RangeInclusive<T>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<RangeInclusiveGenerator<Start, End> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<RangeInclusiveGenerator<Start, End> as ValueGenerator>::Output> where
D: Driver,
impl<G> ValueGenerator for [G; 19] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 19]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 19] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 19] as ValueGenerator>::Output> where
D_: Driver,
impl<L, A, B, C, D, E, F, G, H, I, J, K> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L) where
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
E: ValueGenerator,
F: ValueGenerator,
G: ValueGenerator,
H: ValueGenerator,
I: ValueGenerator,
J: ValueGenerator,
K: ValueGenerator,
L: ValueGenerator,
[src]
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
E: ValueGenerator,
F: ValueGenerator,
G: ValueGenerator,
H: ValueGenerator,
I: ValueGenerator,
J: ValueGenerator,
K: ValueGenerator,
L: ValueGenerator,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L) as ValueGenerator>::Output> where
D_: Driver,
impl<Seconds, Nanos> ValueGenerator for DurationGenerator<Seconds, Nanos> where
Nanos: ValueGenerator<Output = u32>,
Seconds: ValueGenerator<Output = u64>,
[src]
Nanos: ValueGenerator<Output = u32>,
Seconds: ValueGenerator<Output = u64>,
type Output = Duration
fn generate<D>(
&self,
driver: &mut D
) -> Option<<DurationGenerator<Seconds, Nanos> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<DurationGenerator<Seconds, Nanos> as ValueGenerator>::Output> where
D: Driver,
impl ValueGenerator for i128
[src]
impl<G, M, T> ValueGenerator for MapGenerator<G, M> where
G: ValueGenerator,
M: Fn(<G as ValueGenerator>::Output) -> T,
[src]
G: ValueGenerator,
M: Fn(<G as ValueGenerator>::Output) -> T,
type Output = T
fn generate<D>(
&self,
driver: &mut D
) -> Option<<MapGenerator<G, M> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<MapGenerator<G, M> as ValueGenerator>::Output> where
D: Driver,
impl<C, A, B> ValueGenerator for (A, B, C) where
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
[src]
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C) as ValueGenerator>::Output> where
D_: Driver,
impl<T> ValueGenerator for RangeTo<T> where
T: BoundedValue<RangeTo<T>> + TypeGenerator,
[src]
T: BoundedValue<RangeTo<T>> + TypeGenerator,
type Output = T
fn generate<D>(
&self,
driver: &mut D
) -> Option<<RangeTo<T> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<RangeTo<T> as ValueGenerator>::Output> where
D: Driver,
impl<P, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
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,
[src]
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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as ValueGenerator>::Output> where
D_: Driver,
impl<G, F> ValueGenerator for FilterGenerator<G, F> where
F: Fn(&<G as ValueGenerator>::Output) -> bool,
G: ValueGenerator,
[src]
F: Fn(&<G as ValueGenerator>::Output) -> bool,
G: ValueGenerator,
type Output = <G as ValueGenerator>::Output
fn generate<D>(
&self,
driver: &mut D
) -> Option<<FilterGenerator<G, F> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<FilterGenerator<G, F> as ValueGenerator>::Output> where
D: Driver,
impl<V, Selector> ValueGenerator for OptionGenerator<V, Selector> where
Selector: ValueGenerator<Output = bool>,
V: ValueGenerator,
[src]
Selector: ValueGenerator<Output = bool>,
V: ValueGenerator,
type Output = Option<<V as ValueGenerator>::Output>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<OptionGenerator<V, Selector> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<OptionGenerator<V, Selector> as ValueGenerator>::Output> where
D: Driver,
impl<V, K> ValueGenerator for HashMap<K, V, RandomState> where
K: ValueGenerator,
V: ValueGenerator,
<K as ValueGenerator>::Output: Sized,
<K as ValueGenerator>::Output: Hash,
<K as ValueGenerator>::Output: Eq,
[src]
K: ValueGenerator,
V: ValueGenerator,
<K as ValueGenerator>::Output: Sized,
<K as ValueGenerator>::Output: Hash,
<K as ValueGenerator>::Output: Eq,
type Output = HashMap<<K as ValueGenerator>::Output, <V as ValueGenerator>::Output, RandomState>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<HashMap<K, V, RandomState> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<HashMap<K, V, RandomState> as ValueGenerator>::Output> where
D: Driver,
impl<G> ValueGenerator for [G; 16] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 16]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 16] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 16] as ValueGenerator>::Output> where
D_: Driver,
impl<AD, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC> 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) where
A: ValueGenerator,
AA: ValueGenerator,
AB: ValueGenerator,
AC: ValueGenerator,
AD: 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,
[src]
A: ValueGenerator,
AA: ValueGenerator,
AB: ValueGenerator,
AC: ValueGenerator,
AD: 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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output, <AA as ValueGenerator>::Output, <AB as ValueGenerator>::Output, <AC as ValueGenerator>::Output, <AD as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) as ValueGenerator>::Output> where
D_: Driver,
impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
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,
[src]
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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 24] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 24]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 24] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 24] as ValueGenerator>::Output> where
D_: Driver,
impl<Y, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> 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) where
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,
[src]
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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as ValueGenerator>::Output> where
D_: Driver,
impl<J, A, B, C, D, E, F, G, H, I> ValueGenerator for (A, B, C, D, E, F, G, H, I, J) where
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
E: ValueGenerator,
F: ValueGenerator,
G: ValueGenerator,
H: ValueGenerator,
I: ValueGenerator,
J: ValueGenerator,
[src]
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
E: ValueGenerator,
F: ValueGenerator,
G: ValueGenerator,
H: ValueGenerator,
I: ValueGenerator,
J: ValueGenerator,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J) as ValueGenerator>::Output> where
D_: Driver,
impl<AF, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE> 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) where
A: ValueGenerator,
AA: ValueGenerator,
AB: ValueGenerator,
AC: ValueGenerator,
AD: ValueGenerator,
AE: ValueGenerator,
AF: 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,
[src]
A: ValueGenerator,
AA: ValueGenerator,
AB: ValueGenerator,
AC: ValueGenerator,
AD: ValueGenerator,
AE: ValueGenerator,
AF: 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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output, <AA as ValueGenerator>::Output, <AB as ValueGenerator>::Output, <AC as ValueGenerator>::Output, <AD as ValueGenerator>::Output, <AE as ValueGenerator>::Output, <AF as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF) as ValueGenerator>::Output> where
D_: Driver,
impl ValueGenerator for bool
[src]
type Output = bool
fn generate<D>(
&self,
_driver: &mut D
) -> Option<<bool as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
_driver: &mut D
) -> Option<<bool as ValueGenerator>::Output> where
D: Driver,
impl<M, A, B, C, D, E, F, G, H, I, J, K, L> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
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,
[src]
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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M) as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 17] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 17]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 17] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 17] as ValueGenerator>::Output> where
D_: Driver,
impl<Z, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> 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) where
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,
[src]
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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as ValueGenerator>::Output> where
D_: Driver,
impl<Start, End, T> ValueGenerator for RangeGenerator<Start, End> where
End: ValueGenerator<Output = T>,
Start: ValueGenerator<Output = T>,
[src]
End: ValueGenerator<Output = T>,
Start: ValueGenerator<Output = T>,
type Output = Range<T>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<RangeGenerator<Start, End> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<RangeGenerator<Start, End> as ValueGenerator>::Output> where
D: Driver,
impl<V, L, Len> ValueGenerator for BinaryHeapGenerator<V, L> where
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
V: ValueGenerator,
<V as ValueGenerator>::Output: Sized,
<V as ValueGenerator>::Output: Ord,
[src]
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
V: ValueGenerator,
<V as ValueGenerator>::Output: Sized,
<V as ValueGenerator>::Output: Ord,
type Output = BinaryHeap<<V as ValueGenerator>::Output>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<BinaryHeapGenerator<V, L> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<BinaryHeapGenerator<V, L> as ValueGenerator>::Output> where
D: Driver,
impl<V, L, Len> ValueGenerator for HashSetGenerator<V, L> where
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
V: ValueGenerator,
<V as ValueGenerator>::Output: Sized,
<V as ValueGenerator>::Output: Hash,
<V as ValueGenerator>::Output: Eq,
[src]
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
V: ValueGenerator,
<V as ValueGenerator>::Output: Sized,
<V as ValueGenerator>::Output: Hash,
<V as ValueGenerator>::Output: Eq,
type Output = HashSet<<V as ValueGenerator>::Output, RandomState>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<HashSetGenerator<V, L> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<HashSetGenerator<V, L> as ValueGenerator>::Output> where
D: Driver,
impl<O> ValueGenerator for OneValueOf<O> where
O: OneValueOfGenerator,
[src]
O: OneValueOfGenerator,
type Output = <O as OneValueOfGenerator>::Output
fn generate<R>(
&self,
driver: &mut R
) -> Option<<OneValueOf<O> as ValueGenerator>::Output> where
R: Driver,
[src]
&self,
driver: &mut R
) -> Option<<OneValueOf<O> as ValueGenerator>::Output> where
R: Driver,
impl<X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> 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) where
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,
[src]
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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as ValueGenerator>::Output> where
D_: Driver,
impl<K, A, B, C, D, E, F, G, H, I, J> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K) where
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
E: ValueGenerator,
F: ValueGenerator,
G: ValueGenerator,
H: ValueGenerator,
I: ValueGenerator,
J: ValueGenerator,
K: ValueGenerator,
[src]
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
E: ValueGenerator,
F: ValueGenerator,
G: ValueGenerator,
H: ValueGenerator,
I: ValueGenerator,
J: ValueGenerator,
K: ValueGenerator,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K) as ValueGenerator>::Output> where
D_: Driver,
impl<AB, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA> 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) where
A: ValueGenerator,
AA: ValueGenerator,
AB: 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,
[src]
A: ValueGenerator,
AA: ValueGenerator,
AB: 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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output, <AA as ValueGenerator>::Output, <AB as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB) as ValueGenerator>::Output> where
D_: Driver,
impl<G, A, B, C, D, E, F> ValueGenerator for (A, B, C, D, E, F, G) where
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
E: ValueGenerator,
F: ValueGenerator,
G: ValueGenerator,
[src]
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
E: ValueGenerator,
F: ValueGenerator,
G: ValueGenerator,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G) as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 20] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 20]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 20] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 20] as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 29] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 29]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 29] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 29] as ValueGenerator>::Output> where
D_: Driver,
impl<T> ValueGenerator for RangeInclusive<T> where
T: BoundedValue<RangeInclusive<T>> + TypeGenerator,
[src]
T: BoundedValue<RangeInclusive<T>> + TypeGenerator,
type Output = T
fn generate<D>(
&self,
driver: &mut D
) -> Option<<RangeInclusive<T> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<RangeInclusive<T> as ValueGenerator>::Output> where
D: Driver,
impl<U, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) where
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,
[src]
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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as ValueGenerator>::Output> where
D_: Driver,
impl<L, Len> ValueGenerator for StringGenerator<L> where
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
[src]
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
type Output = String
fn generate<D>(
&self,
driver: &mut D
) -> Option<<StringGenerator<L> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<StringGenerator<L> as ValueGenerator>::Output> where
D: Driver,
impl<W, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> 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) where
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,
[src]
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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as ValueGenerator>::Output> where
D_: Driver,
impl<Q, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
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,
[src]
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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as ValueGenerator>::Output> where
D_: Driver,
impl ValueGenerator for u64
[src]
impl<G> ValueGenerator for [G; 6] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 6]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 6] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 6] as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 14] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 14]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 14] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 14] as ValueGenerator>::Output> where
D_: Driver,
impl<G, F, T> ValueGenerator for FilterMapGenerator<G, F> where
F: Fn(<G as ValueGenerator>::Output) -> Option<T>,
G: ValueGenerator,
[src]
F: Fn(<G as ValueGenerator>::Output) -> Option<T>,
G: ValueGenerator,
type Output = T
fn generate<D>(
&self,
driver: &mut D
) -> Option<<FilterMapGenerator<G, F> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<FilterMapGenerator<G, F> as ValueGenerator>::Output> where
D: Driver,
impl ValueGenerator for i32
[src]
impl ValueGenerator for i16
[src]
impl ValueGenerator for u16
[src]
impl<G> ValueGenerator for [G; 2] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 2]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 2] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 2] as ValueGenerator>::Output> where
D_: Driver,
impl<F, A, B, C, D, E> ValueGenerator for (A, B, C, D, E, F) where
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
E: ValueGenerator,
F: ValueGenerator,
[src]
A: ValueGenerator,
B: ValueGenerator,
C: ValueGenerator,
D: ValueGenerator,
E: ValueGenerator,
F: ValueGenerator,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F) as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 31] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 31]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 31] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 31] as ValueGenerator>::Output> where
D_: Driver,
impl<V> ValueGenerator for LinkedList<V> where
V: ValueGenerator,
[src]
V: ValueGenerator,
type Output = LinkedList<<V as ValueGenerator>::Output>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<LinkedList<V> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<LinkedList<V> as ValueGenerator>::Output> where
D: Driver,
impl<O, A, B, C, D, E, F, G, H, I, J, K, L, M, N> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
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,
[src]
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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 3] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 3]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 3] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 3] as ValueGenerator>::Output> where
D_: Driver,
impl ValueGenerator for i64
[src]
impl<G> ValueGenerator for [G; 32] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 32]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 32] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 32] as ValueGenerator>::Output> where
D_: Driver,
impl<T> ValueGenerator for RangeToInclusive<T> where
T: BoundedValue<RangeToInclusive<T>> + TypeGenerator,
[src]
T: BoundedValue<RangeToInclusive<T>> + TypeGenerator,
type Output = T
fn generate<D>(
&self,
driver: &mut D
) -> Option<<RangeToInclusive<T> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<RangeToInclusive<T> as ValueGenerator>::Output> where
D: Driver,
impl<V, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) where
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,
[src]
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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as ValueGenerator>::Output> where
D_: Driver,
impl ValueGenerator for f32
[src]
impl<V> ValueGenerator for HashSet<V, RandomState> where
V: ValueGenerator,
<V as ValueGenerator>::Output: Sized,
<V as ValueGenerator>::Output: Hash,
<V as ValueGenerator>::Output: Eq,
[src]
V: ValueGenerator,
<V as ValueGenerator>::Output: Sized,
<V as ValueGenerator>::Output: Hash,
<V as ValueGenerator>::Output: Eq,
type Output = HashSet<<V as ValueGenerator>::Output, RandomState>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<HashSet<V, RandomState> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<HashSet<V, RandomState> as ValueGenerator>::Output> where
D: Driver,
impl<N, A, B, C, D, E, F, G, H, I, J, K, L, M> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
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,
[src]
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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 9] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 9]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 9] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 9] as ValueGenerator>::Output> where
D_: Driver,
impl<V, L, Len> ValueGenerator for VecGenerator<V, L> where
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
V: ValueGenerator,
[src]
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
V: ValueGenerator,
type Output = Vec<<V as ValueGenerator>::Output>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<VecGenerator<V, L> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<VecGenerator<V, L> as ValueGenerator>::Output> where
D: Driver,
impl<B, A> ValueGenerator for (A, B) where
A: ValueGenerator,
B: ValueGenerator,
[src]
A: ValueGenerator,
B: ValueGenerator,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B) as ValueGenerator>::Output> where
D_: Driver,
impl<V, L, Len> ValueGenerator for VecDequeGenerator<V, L> where
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
V: ValueGenerator,
[src]
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
V: ValueGenerator,
type Output = VecDeque<<V as ValueGenerator>::Output>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<VecDequeGenerator<V, L> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<VecDequeGenerator<V, L> as ValueGenerator>::Output> where
D: Driver,
impl<G> ValueGenerator for [G; 26] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 26]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 26] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 26] as ValueGenerator>::Output> where
D_: Driver,
impl<V, L, Len> ValueGenerator for LinkedListGenerator<V, L> where
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
V: ValueGenerator,
[src]
L: ValueGenerator<Output = Len>,
Len: Into<usize>,
V: ValueGenerator,
type Output = LinkedList<<V as ValueGenerator>::Output>
fn generate<D>(
&self,
driver: &mut D
) -> Option<<LinkedListGenerator<V, L> as ValueGenerator>::Output> where
D: Driver,
[src]
&self,
driver: &mut D
) -> Option<<LinkedListGenerator<V, L> as ValueGenerator>::Output> where
D: Driver,
impl ValueGenerator for usize
[src]
impl<G> ValueGenerator for [G; 7] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 7]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 7] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 7] as ValueGenerator>::Output> where
D_: Driver,
impl ValueGenerator for u128
[src]
impl<G> ValueGenerator for [G; 5] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 5]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 5] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 5] as ValueGenerator>::Output> where
D_: Driver,
impl<R, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where
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,
[src]
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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as ValueGenerator>::Output> where
D_: Driver,
impl<A> ValueGenerator for (A,) where
A: ValueGenerator,
[src]
A: ValueGenerator,
type Output = (<A as ValueGenerator>::Output,)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A,) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A,) as ValueGenerator>::Output> where
D_: Driver,
impl<S, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) where
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,
[src]
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,
type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output)
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as ValueGenerator>::Output> where
D_: Driver,
impl<G> ValueGenerator for [G; 12] where
G: ValueGenerator,
[src]
G: ValueGenerator,
type Output = [<G as ValueGenerator>::Output; 12]
fn generate<D_>(
&self,
driver: &mut D_
) -> Option<<[G; 12] as ValueGenerator>::Output> where
D_: Driver,
[src]
&self,
driver: &mut D_
) -> Option<<[G; 12] as ValueGenerator>::Output> where
D_: Driver,