[−][src]Trait bolero_generator::TypeGenerator

pub trait TypeGenerator: Sized {
    fn generate<D: Driver>(driver: &mut D) -> Option<Self>;

    fn mutate<D: Driver>(&mut self, driver: &mut D) -> Option<()> { ... }
    fn gen() -> TypeValueGenerator<Self> { ... }
}

Generate a value for a given type

Required methods

`fn generate<D: Driver>(driver: &mut D) -> Option<Self>`

Generates a value with the given driver

Loading content...

Provided methods

`fn mutate<D: Driver>(&mut self, driver: &mut D) -> Option<()>`

Mutates an existing value with the given driver

`fn gen() -> TypeValueGenerator<Self>`

Returns a generator for a given type

Loading content...

Implementations on Foreign Types

`impl<T: TypeGenerator> TypeGenerator for Box<T>`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for Box<[T]>`[src]

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

`impl TypeGenerator for Box<str>`[src]

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

`impl TypeGenerator for String`[src]

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

`impl<T: TypeGenerator> TypeGenerator for Arc<T>`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for Rc<T>`[src]

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

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

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 1]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 2]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 3]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 4]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 5]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 6]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 7]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 8]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 9]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 10]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 11]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 12]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 13]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 14]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 15]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 16]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 17]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 18]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 19]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 20]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 21]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 22]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 23]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 24]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 25]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 26]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 27]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 28]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 29]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 30]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 31]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 32]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 33]`[src]

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

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

`impl TypeGenerator for AtomicBool`[src]

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

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

`impl TypeGenerator for AtomicI8`[src]

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

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

`impl TypeGenerator for AtomicU8`[src]

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

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

`impl TypeGenerator for AtomicI16`[src]

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

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

`impl TypeGenerator for AtomicU16`[src]

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

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

`impl TypeGenerator for AtomicI32`[src]

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

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

`impl TypeGenerator for AtomicU32`[src]

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

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

`impl TypeGenerator for AtomicI64`[src]

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

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

`impl TypeGenerator for AtomicU64`[src]

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

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

`impl TypeGenerator for AtomicIsize`[src]

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

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

`impl TypeGenerator for AtomicUsize`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for Cell<T>`[src]

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

`impl<T: TypeGenerator> TypeGenerator for RefCell<T>`[src]

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

`impl<T: TypeGenerator> TypeGenerator for UnsafeCell<T>`[src]

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

`impl TypeGenerator for bool`[src]

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

`impl TypeGenerator for char`[src]

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

`impl TypeGenerator for u8`[src]

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

`impl TypeGenerator for i8`[src]

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

`impl TypeGenerator for u16`[src]

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

`impl TypeGenerator for i16`[src]

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

`impl TypeGenerator for u32`[src]

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

`impl TypeGenerator for i32`[src]

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

`impl TypeGenerator for u64`[src]

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

`impl TypeGenerator for i64`[src]

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

`impl TypeGenerator for u128`[src]

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

`impl TypeGenerator for i128`[src]

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

`impl TypeGenerator for usize`[src]

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

`impl TypeGenerator for isize`[src]

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

`impl TypeGenerator for f32`[src]

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

`impl TypeGenerator for f64`[src]

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

`impl TypeGenerator for NonZeroI8`[src]

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

`impl TypeGenerator for NonZeroU8`[src]

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

`impl TypeGenerator for NonZeroI16`[src]

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

`impl TypeGenerator for NonZeroU16`[src]

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

`impl TypeGenerator for NonZeroI32`[src]

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

`impl TypeGenerator for NonZeroU32`[src]

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

`impl TypeGenerator for NonZeroI64`[src]

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

`impl TypeGenerator for NonZeroU64`[src]

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

`impl TypeGenerator for NonZeroI128`[src]

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

`impl TypeGenerator for NonZeroU128`[src]

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

`impl TypeGenerator for NonZeroIsize`[src]

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

`impl TypeGenerator for NonZeroUsize`[src]

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

`impl<T: TypeGenerator> TypeGenerator for Range<T>`[src]

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

`impl<T: TypeGenerator> TypeGenerator for RangeInclusive<T>`[src]

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

`impl<Ok: TypeGenerator, Err: TypeGenerator> TypeGenerator for Result<Ok, Err>`[src]

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

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

`impl<Left: TypeGenerator, Right: TypeGenerator> TypeGenerator for Either<Left, Right>`[src]

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

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

`impl<V: TypeGenerator> TypeGenerator for Option<V>`[src]

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

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

`impl TypeGenerator for Duration`[src]

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

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

`impl TypeGenerator for ()`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Loading content...

Implementors

`impl<K: TypeGenerator + Ord, V: TypeGenerator> TypeGenerator for BTreeMap<K, V>`[src]

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

`impl<T: ?Sized> TypeGenerator for Cow<'static, T> where T: ToOwned, <T as ToOwned>::Owned: TypeGenerator,` [src]

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

`impl<V: TypeGenerator + Ord> TypeGenerator for BTreeSet<V>`[src]

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

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

`impl<V: TypeGenerator + Ord> TypeGenerator for BinaryHeap<V>`[src]

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

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

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

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

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

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

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

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

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

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

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

Loading content...

[−][src]Trait bolero_generator::TypeGenerator

Required methods

fn generate<D: Driver>(driver: &mut D) -> Option<Self>

Provided methods

fn mutate<D: Driver>(&mut self, driver: &mut D) -> Option<()>

fn gen() -> TypeValueGenerator<Self>

Implementations on Foreign Types

impl<T: TypeGenerator> TypeGenerator for Box<T>[src]

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

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

impl<T: TypeGenerator> TypeGenerator for Box<[T]>[src]

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

impl TypeGenerator for Box<str>[src]

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

impl TypeGenerator for String[src]

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

impl<T: TypeGenerator> TypeGenerator for Arc<T>[src]

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

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

impl<T: TypeGenerator> TypeGenerator for Rc<T>[src]

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

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

impl<T> TypeGenerator for [T; 0][src]

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

impl<T: TypeGenerator> TypeGenerator for [T; 1][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 2][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 3][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 4][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 5][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 6][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 7][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 8][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 9][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 10][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 11][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 12][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 13][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 14][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 15][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 16][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 17][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 18][src]

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

fn mutate<D_: Driver>(&mut self, driver: &mut D_) -> Option<()>[src]

impl<T: TypeGenerator> TypeGenerator for [T; 19][src]

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

`fn generate<D: Driver>(driver: &mut D) -> Option<Self>`

`fn mutate<D: Driver>(&mut self, driver: &mut D) -> Option<()>`

`fn gen() -> TypeValueGenerator<Self>`

`impl<T: TypeGenerator> TypeGenerator for Box<T>`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for Box<[T]>`[src]

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

`impl TypeGenerator for Box<str>`[src]

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

`impl TypeGenerator for String`[src]

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

`impl<T: TypeGenerator> TypeGenerator for Arc<T>`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for Rc<T>`[src]

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

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

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 1]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 2]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 3]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 4]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 5]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 6]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 7]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 8]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 9]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 10]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 11]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 12]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 13]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 14]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 15]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 16]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 17]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 18]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 19]`[src]

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

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

`impl<T: TypeGenerator> TypeGenerator for [T; 20]`[src]

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

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