Trait bolero_generator::TypeGenerator

source · [−]

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> { ... }
}

Expand description

Generate a value for a given type

Required Methods

source

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

Generates a value with the given driver

Provided Methods

source

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

Mutates an existing value with the given driver

source

fn gen() -> TypeValueGenerator<Self>

Returns a generator for a given type

Implementations on Foreign Types

source

impl<K: TypeGenerator + Hash + Eq, V: TypeGenerator> TypeGenerator for HashMap<K, V>

source

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

source

impl<T: TypeGenerator> TypeGenerator for Mutex<T>

source

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

source

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

source

impl<T> TypeGenerator for [T; 0]

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

impl TypeGenerator for AtomicBool

source

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

source

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

source

impl TypeGenerator for AtomicI8

source

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

source

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

source

impl TypeGenerator for AtomicU8

source

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

source

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

source

impl TypeGenerator for AtomicI16

source

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

source

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

source

impl TypeGenerator for AtomicU16

source

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

source

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

source

impl TypeGenerator for AtomicI32

source

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

source

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

source

impl TypeGenerator for AtomicU32

source

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

source

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

source

impl TypeGenerator for AtomicI64

source

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

source

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

source

impl TypeGenerator for AtomicU64

source

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

source

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

source

impl TypeGenerator for AtomicIsize

source

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

source

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

source

impl TypeGenerator for AtomicUsize

source

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

source

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

source

impl<T: TypeGenerator> TypeGenerator for Cell<T>

source

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

source

impl<T: TypeGenerator> TypeGenerator for RefCell<T>

source

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

source

impl<T: TypeGenerator> TypeGenerator for UnsafeCell<T>

source

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

source

impl TypeGenerator for bool

source

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

source

impl TypeGenerator for char

source

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

source

impl TypeGenerator for u8

source

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

source

impl TypeGenerator for i8

source

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

source

impl TypeGenerator for u16

source

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

source

impl TypeGenerator for i16

source

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

source

impl TypeGenerator for u32

source

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

source

impl TypeGenerator for i32

source

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

source

impl TypeGenerator for u64

source

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

source

impl TypeGenerator for i64

source

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

source

impl TypeGenerator for u128

source

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

source

impl TypeGenerator for i128

source

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

source

impl TypeGenerator for usize

source

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

source

impl TypeGenerator for isize

source

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

source

impl TypeGenerator for f32

source

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

source

impl TypeGenerator for f64

source

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

source

impl TypeGenerator for NonZeroI8

source

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

source

impl TypeGenerator for NonZeroU8

source

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

source

impl TypeGenerator for NonZeroI16

source

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

source

impl TypeGenerator for NonZeroU16

source

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

source

impl TypeGenerator for NonZeroI32

source

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

source

impl TypeGenerator for NonZeroU32

source

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

source

impl TypeGenerator for NonZeroI64

source

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

source

impl TypeGenerator for NonZeroU64

source

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

source

impl TypeGenerator for NonZeroI128

source

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

source

impl TypeGenerator for NonZeroU128

source

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

source

impl TypeGenerator for NonZeroIsize

source

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

source

impl TypeGenerator for NonZeroUsize

source

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

source

impl<T: TypeGenerator> TypeGenerator for Range<T>

source

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

source

impl<T: TypeGenerator> TypeGenerator for RangeInclusive<T>

source

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

source

impl<Ok: TypeGenerator, Err: TypeGenerator> TypeGenerator for Result<Ok, Err>

source

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

source

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

source

impl<Left: TypeGenerator, Right: TypeGenerator> TypeGenerator for Either<Left, Right>

source

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

source

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

source

impl<V: TypeGenerator> TypeGenerator for Option<V>

source

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

source

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

source

impl TypeGenerator for Duration

source

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

source

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

source

impl TypeGenerator for ()

source

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

source

impl<A: TypeGenerator> TypeGenerator for (A,)

source

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

source

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

source

impl<B: TypeGenerator, A: TypeGenerator> TypeGenerator for (A, B)

source

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

source

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

source

impl<C: TypeGenerator, A: TypeGenerator, B: TypeGenerator> TypeGenerator for (A, B, C)

source

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

source

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

source

impl<D: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator> TypeGenerator for (A, B, C, D)

source

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

source

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

source

impl<E: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator> TypeGenerator for (A, B, C, D, E)

source

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

source

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

source

impl<F: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator> TypeGenerator for (A, B, C, D, E, F)

source

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

source

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

source

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

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

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)

source

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

source

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

source

impl<T> TypeGenerator for PhantomData<T>

source

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

Implementors

source

impl<K: TypeGenerator + Ord, V: TypeGenerator> TypeGenerator for BTreeMap<K, V>

source

impl<T> TypeGenerator for Cow<'static, T>where
T: ToOwned + ?Sized,
<T as ToOwned>::Owned: TypeGenerator,

source

impl<V: TypeGenerator + Ord> TypeGenerator for BTreeSet<V>

source

impl<V: TypeGenerator + Ord> TypeGenerator for BinaryHeap<V>

source

impl<V: TypeGenerator> TypeGenerator for LinkedList<V>

source

impl<V: TypeGenerator> TypeGenerator for Vec<V>

source

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>

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

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

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

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

impl TypeGenerator for Box<str>

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

impl TypeGenerator for String

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

impl<T: TypeGenerator> TypeGenerator for Arc<T>

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

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

impl<T: TypeGenerator> TypeGenerator for Rc<T>

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

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

impl<V: TypeGenerator + Hash + Eq> TypeGenerator for HashSet<V>

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

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

impl<K: TypeGenerator + Hash + Eq, V: TypeGenerator> TypeGenerator for HashMap<K, V>

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

impl<T: TypeGenerator> TypeGenerator for Mutex<T>

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

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

impl<T> TypeGenerator for [T; 0]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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