[−][src]Trait bolero_engine::TypeGenerator
Generate a value for a given type
Required methods
fn generate<D>(driver: &mut D) -> Option<Self> where
D: Driver,
D: Driver,
Generates a value with the given driver
Provided methods
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
D: Driver,
Mutates an existing value with the given driver
fn gen() -> TypeValueGenerator<Self>
Returns a generator for a given type
Implementations on Foreign Types
impl<P, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
fn generate<D_>(
driver: &mut D_
) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> where
D_: Driver,
[src]
driver: &mut D_
) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for NonZeroI64
[src]
impl TypeGenerator for NonZeroI128
[src]
impl<T> TypeGenerator for [T; 12] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 12]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<D, A, B, C> TypeGenerator for (A, B, C, D) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<(A, B, C, D)> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<C, A, B> TypeGenerator for (A, B, C) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<(A, B, C)> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 10] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 10]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<I, A, B, C, D, E, F, G, H> TypeGenerator for (A, B, C, D, E, F, G, H, I) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<(A, B, C, D, E, F, G, H, I)> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<N, A, B, C, D, E, F, G, H, I, J, K, L, M> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
fn generate<D_>(
driver: &mut D_
) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)> where
D_: Driver,
[src]
driver: &mut D_
) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
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> TypeGenerator 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: TypeGenerator,
AA: TypeGenerator,
AB: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
Z: TypeGenerator,
[src]
A: TypeGenerator,
AA: TypeGenerator,
AB: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
Z: TypeGenerator,
fn generate<D_>(
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)> where
D_: Driver,
[src]
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)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<H, A, B, C, D, E, F, G> TypeGenerator for (A, B, C, D, E, F, G, H) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<(A, B, C, D, E, F, G, H)> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<V> TypeGenerator for Option<V> where
V: TypeGenerator,
[src]
V: TypeGenerator,
fn generate<D>(driver: &mut D) -> Option<Option<V>> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl<T> TypeGenerator for [T; 8] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 8]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 4] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 4]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 6] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 6]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for Duration
[src]
fn generate<D>(driver: &mut D) -> Option<Duration> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl<Ok, Err> TypeGenerator for Result<Ok, Err> where
Err: TypeGenerator,
Ok: TypeGenerator,
[src]
Err: TypeGenerator,
Ok: TypeGenerator,
fn generate<D>(driver: &mut D) -> Option<Result<Ok, Err>> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl<T> TypeGenerator for [T; 22] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 22]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for i128
[src]
impl<W, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> TypeGenerator 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: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
fn generate<D_>(
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)> where
D_: Driver,
[src]
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)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
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> TypeGenerator 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: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
Z: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
Z: TypeGenerator,
fn generate<D_>(
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)> where
D_: Driver,
[src]
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)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for Box<[T]> where
T: TypeGenerator,
[src]
T: TypeGenerator,
impl<T> TypeGenerator for [T; 15] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 15]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<V> TypeGenerator for VecDeque<V> where
V: TypeGenerator,
[src]
V: TypeGenerator,
fn generate<D>(driver: &mut D) -> Option<VecDeque<V>> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl<F, A, B, C, D, E> TypeGenerator for (A, B, C, D, E, F) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<(A, B, C, D, E, F)> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for AtomicI32
[src]
fn generate<D>(driver: &mut D) -> Option<AtomicI32> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl TypeGenerator for i8
[src]
impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
fn generate<D_>(
driver: &mut D_
) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)> where
D_: Driver,
[src]
driver: &mut D_
) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for f64
[src]
impl<T> TypeGenerator for [T; 5] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 5]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for AtomicU32
[src]
fn generate<D>(driver: &mut D) -> Option<AtomicU32> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl TypeGenerator for NonZeroU32
[src]
impl TypeGenerator for ()
[src]
impl<T> TypeGenerator for [T; 28] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 28]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for AtomicBool
[src]
fn generate<D>(driver: &mut D) -> Option<AtomicBool> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl<E, A, B, C, D> TypeGenerator for (A, B, C, D, E) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<(A, B, C, D, E)> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<S, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
fn generate<D_>(
driver: &mut D_
) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)> where
D_: Driver,
[src]
driver: &mut D_
) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for AtomicI8
[src]
fn generate<D>(driver: &mut D) -> Option<AtomicI8> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl TypeGenerator for AtomicU64
[src]
fn generate<D>(driver: &mut D) -> Option<AtomicU64> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl TypeGenerator for NonZeroU64
[src]
impl<K, A, B, C, D, E, F, G, H, I, J> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<(A, B, C, D, E, F, G, H, I, J, K)> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<Left, Right> TypeGenerator for Either<Left, Right> where
Left: TypeGenerator,
Right: TypeGenerator,
[src]
Left: TypeGenerator,
Right: TypeGenerator,
fn generate<D>(driver: &mut D) -> Option<Either<Left, Right>> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
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> TypeGenerator 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: TypeGenerator,
AA: TypeGenerator,
AB: TypeGenerator,
AC: TypeGenerator,
AD: TypeGenerator,
AE: TypeGenerator,
AF: TypeGenerator,
AG: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
Z: TypeGenerator,
[src]
A: TypeGenerator,
AA: TypeGenerator,
AB: TypeGenerator,
AC: TypeGenerator,
AD: TypeGenerator,
AE: TypeGenerator,
AF: TypeGenerator,
AG: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
Z: TypeGenerator,
fn generate<D_>(
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)> where
D_: Driver,
[src]
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)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
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> TypeGenerator 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: TypeGenerator,
AA: TypeGenerator,
AB: TypeGenerator,
AC: TypeGenerator,
AD: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
Z: TypeGenerator,
[src]
A: TypeGenerator,
AA: TypeGenerator,
AB: TypeGenerator,
AC: TypeGenerator,
AD: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
Z: TypeGenerator,
fn generate<D_>(
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)> where
D_: Driver,
[src]
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)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
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> TypeGenerator 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: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
fn generate<D_>(
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)> where
D_: Driver,
[src]
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)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 26] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 26]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for AtomicU8
[src]
fn generate<D>(driver: &mut D) -> Option<AtomicU8> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl<O, A, B, C, D, E, F, G, H, I, J, K, L, M, N> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
fn generate<D_>(
driver: &mut D_
) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)> where
D_: Driver,
[src]
driver: &mut D_
) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<K, V> TypeGenerator for HashMap<K, V, RandomState> where
K: TypeGenerator + Eq + Hash,
V: TypeGenerator,
[src]
K: TypeGenerator + Eq + Hash,
V: TypeGenerator,
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> TypeGenerator 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: TypeGenerator,
AA: TypeGenerator,
AB: TypeGenerator,
AC: TypeGenerator,
AD: TypeGenerator,
AE: TypeGenerator,
AF: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
Z: TypeGenerator,
[src]
A: TypeGenerator,
AA: TypeGenerator,
AB: TypeGenerator,
AC: TypeGenerator,
AD: TypeGenerator,
AE: TypeGenerator,
AF: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
Z: TypeGenerator,
fn generate<D_>(
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)> where
D_: Driver,
[src]
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)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 27] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 27]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 14] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 14]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
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> TypeGenerator 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: TypeGenerator,
AA: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
Z: TypeGenerator,
[src]
A: TypeGenerator,
AA: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
Z: TypeGenerator,
fn generate<D_>(
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)> where
D_: Driver,
[src]
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)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
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> TypeGenerator 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: TypeGenerator,
AA: TypeGenerator,
AB: TypeGenerator,
AC: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
Z: TypeGenerator,
[src]
A: TypeGenerator,
AA: TypeGenerator,
AB: TypeGenerator,
AC: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
Z: TypeGenerator,
fn generate<D_>(
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)> where
D_: Driver,
[src]
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)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for NonZeroU8
[src]
impl TypeGenerator for AtomicI64
[src]
fn generate<D>(driver: &mut D) -> Option<AtomicI64> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl<T> TypeGenerator for [T; 13] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 13]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for Rc<T> where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D>(driver: &mut D) -> Option<Rc<T>> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl TypeGenerator for isize
[src]
impl TypeGenerator for i32
[src]
impl<K, V> TypeGenerator for BTreeMap<K, V> where
K: TypeGenerator + Ord,
V: TypeGenerator,
[src]
K: TypeGenerator + Ord,
V: TypeGenerator,
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> TypeGenerator 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: TypeGenerator,
AA: TypeGenerator,
AB: TypeGenerator,
AC: TypeGenerator,
AD: TypeGenerator,
AE: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
Z: TypeGenerator,
[src]
A: TypeGenerator,
AA: TypeGenerator,
AB: TypeGenerator,
AC: TypeGenerator,
AD: TypeGenerator,
AE: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
Y: TypeGenerator,
Z: TypeGenerator,
fn generate<D_>(
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)> where
D_: Driver,
[src]
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)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for AtomicU16
[src]
fn generate<D>(driver: &mut D) -> Option<AtomicU16> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl<J, A, B, C, D, E, F, G, H, I> TypeGenerator for (A, B, C, D, E, F, G, H, I, J) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<(A, B, C, D, E, F, G, H, I, J)> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 19] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 19]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for Arc<T> where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D>(driver: &mut D) -> Option<Arc<T>> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl<V> TypeGenerator for LinkedList<V> where
V: TypeGenerator,
[src]
V: TypeGenerator,
fn generate<D>(driver: &mut D) -> Option<LinkedList<V>> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl<T> TypeGenerator for PhantomData<T>
[src]
impl<T> TypeGenerator for [T; 0]
[src]
impl<T> TypeGenerator for [T; 23] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 23]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<V> TypeGenerator for Vec<V> where
V: TypeGenerator,
[src]
V: TypeGenerator,
fn generate<D>(driver: &mut D) -> Option<Vec<V>> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl TypeGenerator for u64
[src]
impl TypeGenerator for AtomicIsize
[src]
fn generate<D>(driver: &mut D) -> Option<AtomicIsize> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl<U, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
fn generate<D_>(
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)> where
D_: Driver,
[src]
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)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for usize
[src]
impl<T> TypeGenerator for [T; 18] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 18]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for String
[src]
impl<V> TypeGenerator for HashSet<V, RandomState> where
V: TypeGenerator + Eq + Hash,
[src]
V: TypeGenerator + Eq + Hash,
fn generate<D>(driver: &mut D) -> Option<HashSet<V, RandomState>> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl<T> TypeGenerator for [T; 25] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 25]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 16] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 16]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 17] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 17]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for Cell<T> where
T: TypeGenerator,
[src]
T: TypeGenerator,
impl TypeGenerator for bool
[src]
impl<T> TypeGenerator for Mutex<T> where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D>(driver: &mut D) -> Option<Mutex<T>> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl TypeGenerator for f32
[src]
impl TypeGenerator for NonZeroU128
[src]
impl<T> TypeGenerator for Box<T> where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D>(driver: &mut D) -> Option<Box<T>> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl<T> TypeGenerator for [T; 31] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 31]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 1] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 1]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<M, A, B, C, D, E, F, G, H, I, J, K, L> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
fn generate<D_>(
driver: &mut D_
) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L, M)> where
D_: Driver,
[src]
driver: &mut D_
) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L, M)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for AtomicI16
[src]
fn generate<D>(driver: &mut D) -> Option<AtomicI16> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl TypeGenerator for NonZeroUsize
[src]
impl<T> TypeGenerator for RefCell<T> where
T: TypeGenerator,
[src]
T: TypeGenerator,
impl<T> TypeGenerator for RangeInclusive<T> where
T: TypeGenerator,
[src]
T: TypeGenerator,
impl<G, A, B, C, D, E, F> TypeGenerator for (A, B, C, D, E, F, G) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<(A, B, C, D, E, F, G)> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 9] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 9]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 7] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 7]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 30] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 30]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 11] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 11]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 33] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 33]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: 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> TypeGenerator 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: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
W: TypeGenerator,
X: TypeGenerator,
fn generate<D_>(
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)> where
D_: Driver,
[src]
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)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 29] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 29]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for NonZeroI16
[src]
impl TypeGenerator for AtomicUsize
[src]
fn generate<D>(driver: &mut D) -> Option<AtomicUsize> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl TypeGenerator for i64
[src]
impl<T> TypeGenerator for UnsafeCell<T> where
T: TypeGenerator,
[src]
T: TypeGenerator,
impl TypeGenerator for NonZeroU16
[src]
impl<T> TypeGenerator for [T; 32] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 32]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for Cow<'static, T> where
T: ToOwned + ?Sized,
<T as ToOwned>::Owned: TypeGenerator,
[src]
T: ToOwned + ?Sized,
<T as ToOwned>::Owned: TypeGenerator,
impl TypeGenerator for u16
[src]
impl<T> TypeGenerator for [T; 21] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 21]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for NonZeroI8
[src]
impl TypeGenerator for i16
[src]
impl TypeGenerator for Box<str>
[src]
impl TypeGenerator for u8
[src]
impl TypeGenerator for u32
[src]
impl<Q, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
fn generate<D_>(
driver: &mut D_
) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)> where
D_: Driver,
[src]
driver: &mut D_
) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<V> TypeGenerator for BTreeSet<V> where
V: TypeGenerator + Ord,
[src]
V: TypeGenerator + Ord,
fn generate<D>(driver: &mut D) -> Option<BTreeSet<V>> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,
impl TypeGenerator for NonZeroIsize
[src]
impl<T> TypeGenerator for [T; 3] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 3]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 20] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 20]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<A> TypeGenerator for (A,) where
A: TypeGenerator,
[src]
A: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<(A,)> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 24] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 24]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<L, A, B, C, D, E, F, G, H, I, J, K> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K, L) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L)> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
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> TypeGenerator 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: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
S: TypeGenerator,
T: TypeGenerator,
U: TypeGenerator,
V: TypeGenerator,
fn generate<D_>(
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)> where
D_: Driver,
[src]
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)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<T> TypeGenerator for [T; 2] where
T: TypeGenerator,
[src]
T: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<[T; 2]> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for NonZeroI32
[src]
impl TypeGenerator for u128
[src]
impl<T> TypeGenerator for Range<T> where
T: TypeGenerator,
[src]
T: TypeGenerator,
impl<B, A> TypeGenerator for (A, B) where
A: TypeGenerator,
B: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
fn generate<D_>(driver: &mut D_) -> Option<(A, B)> where
D_: Driver,
[src]
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl TypeGenerator for char
[src]
impl<R, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
[src]
A: TypeGenerator,
B: TypeGenerator,
C: TypeGenerator,
D: TypeGenerator,
E: TypeGenerator,
F: TypeGenerator,
G: TypeGenerator,
H: TypeGenerator,
I: TypeGenerator,
J: TypeGenerator,
K: TypeGenerator,
L: TypeGenerator,
M: TypeGenerator,
N: TypeGenerator,
O: TypeGenerator,
P: TypeGenerator,
Q: TypeGenerator,
R: TypeGenerator,
fn generate<D_>(
driver: &mut D_
) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)> where
D_: Driver,
[src]
driver: &mut D_
) -> Option<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)> where
D_: Driver,
fn mutate<D_>(&mut self, driver: &mut D_) -> Option<()> where
D_: Driver,
[src]
D_: Driver,
impl<V> TypeGenerator for BinaryHeap<V> where
V: TypeGenerator + Ord,
[src]
V: TypeGenerator + Ord,
fn generate<D>(driver: &mut D) -> Option<BinaryHeap<V>> where
D: Driver,
[src]
D: Driver,
fn mutate<D>(&mut self, driver: &mut D) -> Option<()> where
D: Driver,
[src]
D: Driver,