Trait lain::traits::NewFuzzed[−][src]

pub trait NewFuzzed {
    type RangeType: Debug + Bounded + Default;
    fn new_fuzzed<R: Rng>(
        mutator: &mut Mutator<R>, 
        constraints: Option<&Constraints<Self::RangeType>>
    ) -> Self;
}
Expand description

A data structure that can have a new instance of itself created completely randomly, with optional constraints.

Associated Types

type RangeType: Debug + Bounded + Default[src]

Required methods

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]

Picks a random variant of Self

Implementations on Foreign Types

impl<T> NewFuzzed for Option<T> where
    T: NewFuzzed, [src]

type RangeType = T::RangeType

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Option<T>[src]

impl<T> NewFuzzed for Box<T> where
    T: NewFuzzed, [src]

type RangeType = T::RangeType

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Box<T>[src]

impl<T> NewFuzzed for Vec<T> where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Vec<T>[src]

impl<T> NewFuzzed for Vec<T> where
    T: NewFuzzed + Clone + SerializedSize, [src]

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Vec<T>[src]

impl NewFuzzed for char[src]

type RangeType = u32

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]

impl NewFuzzed for bool[src]

type RangeType = u8

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    _constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]

impl NewFuzzed for u8[src]

type RangeType = u8

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]

impl NewFuzzed for i8[src]

type RangeType = i8

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]

impl NewFuzzed for u16[src]

type RangeType = u16

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]

impl NewFuzzed for i16[src]

type RangeType = i16

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]

impl NewFuzzed for u32[src]

type RangeType = u32

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]

impl NewFuzzed for i32[src]

type RangeType = i32

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]

impl NewFuzzed for u64[src]

type RangeType = u64

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]

impl NewFuzzed for i64[src]

type RangeType = i64

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]

impl NewFuzzed for f32[src]

type RangeType = f32

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]

impl NewFuzzed for f64[src]

type RangeType = f64

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]

impl<T> NewFuzzed for [T; 0] where
    T: NewFuzzed + Clone, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    _mutator: &mut Mutator<R>,
    _constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 0][src]

impl<T> NewFuzzed for [T; 1] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 1][src]

impl<T> NewFuzzed for [T; 1] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 1][src]

impl<T> NewFuzzed for [T; 2] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 2][src]

impl<T> NewFuzzed for [T; 2] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 2][src]

impl<T> NewFuzzed for [T; 3] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 3][src]

impl<T> NewFuzzed for [T; 3] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 3][src]

impl<T> NewFuzzed for [T; 4] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 4][src]

impl<T> NewFuzzed for [T; 4] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 4][src]

impl<T> NewFuzzed for [T; 5] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 5][src]

impl<T> NewFuzzed for [T; 5] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 5][src]

impl<T> NewFuzzed for [T; 6] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 6][src]

impl<T> NewFuzzed for [T; 6] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 6][src]

impl<T> NewFuzzed for [T; 7] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 7][src]

impl<T> NewFuzzed for [T; 7] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 7][src]

impl<T> NewFuzzed for [T; 8] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 8][src]

impl<T> NewFuzzed for [T; 8] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 8][src]

impl<T> NewFuzzed for [T; 9] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 9][src]

impl<T> NewFuzzed for [T; 9] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 9][src]

impl<T> NewFuzzed for [T; 10] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 10][src]

impl<T> NewFuzzed for [T; 10] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 10][src]

impl<T> NewFuzzed for [T; 11] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 11][src]

impl<T> NewFuzzed for [T; 11] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 11][src]

impl<T> NewFuzzed for [T; 12] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 12][src]

impl<T> NewFuzzed for [T; 12] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 12][src]

impl<T> NewFuzzed for [T; 13] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 13][src]

impl<T> NewFuzzed for [T; 13] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 13][src]

impl<T> NewFuzzed for [T; 14] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 14][src]

impl<T> NewFuzzed for [T; 14] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 14][src]

impl<T> NewFuzzed for [T; 15] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 15][src]

impl<T> NewFuzzed for [T; 15] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 15][src]

impl<T> NewFuzzed for [T; 16] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 16][src]

impl<T> NewFuzzed for [T; 16] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 16][src]

impl<T> NewFuzzed for [T; 17] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 17][src]

impl<T> NewFuzzed for [T; 17] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 17][src]

impl<T> NewFuzzed for [T; 18] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 18][src]

impl<T> NewFuzzed for [T; 18] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 18][src]

impl<T> NewFuzzed for [T; 19] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 19][src]

impl<T> NewFuzzed for [T; 19] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 19][src]

impl<T> NewFuzzed for [T; 20] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 20][src]

impl<T> NewFuzzed for [T; 20] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 20][src]

impl<T> NewFuzzed for [T; 21] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 21][src]

impl<T> NewFuzzed for [T; 21] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 21][src]

impl<T> NewFuzzed for [T; 22] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 22][src]

impl<T> NewFuzzed for [T; 22] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 22][src]

impl<T> NewFuzzed for [T; 23] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 23][src]

impl<T> NewFuzzed for [T; 23] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 23][src]

impl<T> NewFuzzed for [T; 24] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 24][src]

impl<T> NewFuzzed for [T; 24] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 24][src]

impl<T> NewFuzzed for [T; 25] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 25][src]

impl<T> NewFuzzed for [T; 25] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 25][src]

impl<T> NewFuzzed for [T; 26] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 26][src]

impl<T> NewFuzzed for [T; 26] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 26][src]

impl<T> NewFuzzed for [T; 27] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 27][src]

impl<T> NewFuzzed for [T; 27] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 27][src]

impl<T> NewFuzzed for [T; 28] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 28][src]

impl<T> NewFuzzed for [T; 28] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 28][src]

impl<T> NewFuzzed for [T; 29] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 29][src]

impl<T> NewFuzzed for [T; 29] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 29][src]

impl<T> NewFuzzed for [T; 30] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 30][src]

impl<T> NewFuzzed for [T; 30] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 30][src]

impl<T> NewFuzzed for [T; 31] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 31][src]

impl<T> NewFuzzed for [T; 31] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 31][src]

impl<T> NewFuzzed for [T; 32] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 32][src]

impl<T> NewFuzzed for [T; 32] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 32][src]

impl<T> NewFuzzed for [T; 33] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 33][src]

impl<T> NewFuzzed for [T; 33] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 33][src]

impl<T> NewFuzzed for [T; 34] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 34][src]

impl<T> NewFuzzed for [T; 34] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 34][src]

impl<T> NewFuzzed for [T; 35] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 35][src]

impl<T> NewFuzzed for [T; 35] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 35][src]

impl<T> NewFuzzed for [T; 36] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 36][src]

impl<T> NewFuzzed for [T; 36] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 36][src]

impl<T> NewFuzzed for [T; 37] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 37][src]

impl<T> NewFuzzed for [T; 37] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 37][src]

impl<T> NewFuzzed for [T; 38] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 38][src]

impl<T> NewFuzzed for [T; 38] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 38][src]

impl<T> NewFuzzed for [T; 39] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 39][src]

impl<T> NewFuzzed for [T; 39] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 39][src]

impl<T> NewFuzzed for [T; 40] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 40][src]

impl<T> NewFuzzed for [T; 40] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 40][src]

impl<T> NewFuzzed for [T; 41] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 41][src]

impl<T> NewFuzzed for [T; 41] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 41][src]

impl<T> NewFuzzed for [T; 42] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 42][src]

impl<T> NewFuzzed for [T; 42] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 42][src]

impl<T> NewFuzzed for [T; 43] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 43][src]

impl<T> NewFuzzed for [T; 43] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 43][src]

impl<T> NewFuzzed for [T; 44] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 44][src]

impl<T> NewFuzzed for [T; 44] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 44][src]

impl<T> NewFuzzed for [T; 45] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 45][src]

impl<T> NewFuzzed for [T; 45] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 45][src]

impl<T> NewFuzzed for [T; 46] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 46][src]

impl<T> NewFuzzed for [T; 46] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 46][src]

impl<T> NewFuzzed for [T; 47] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 47][src]

impl<T> NewFuzzed for [T; 47] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 47][src]

impl<T> NewFuzzed for [T; 48] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 48][src]

impl<T> NewFuzzed for [T; 48] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 48][src]

impl<T> NewFuzzed for [T; 49] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 49][src]

impl<T> NewFuzzed for [T; 49] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 49][src]

impl<T> NewFuzzed for [T; 50] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 50][src]

impl<T> NewFuzzed for [T; 50] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 50][src]

impl<T> NewFuzzed for [T; 51] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 51][src]

impl<T> NewFuzzed for [T; 51] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 51][src]

impl<T> NewFuzzed for [T; 52] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 52][src]

impl<T> NewFuzzed for [T; 52] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 52][src]

impl<T> NewFuzzed for [T; 53] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 53][src]

impl<T> NewFuzzed for [T; 53] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 53][src]

impl<T> NewFuzzed for [T; 54] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 54][src]

impl<T> NewFuzzed for [T; 54] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 54][src]

impl<T> NewFuzzed for [T; 55] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 55][src]

impl<T> NewFuzzed for [T; 55] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 55][src]

impl<T> NewFuzzed for [T; 56] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 56][src]

impl<T> NewFuzzed for [T; 56] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 56][src]

impl<T> NewFuzzed for [T; 57] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 57][src]

impl<T> NewFuzzed for [T; 57] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 57][src]

impl<T> NewFuzzed for [T; 58] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 58][src]

impl<T> NewFuzzed for [T; 58] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 58][src]

impl<T> NewFuzzed for [T; 59] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 59][src]

impl<T> NewFuzzed for [T; 59] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 59][src]

impl<T> NewFuzzed for [T; 60] where
    T: NewFuzzed + Clone + SerializedSize, [src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 60][src]

impl<T> NewFuzzed for [T; 60] where
    T: NewFuzzed + SerializedSize, [src]

type RangeType = usize

default fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> [T; 60][src]

impl NewFuzzed for *mut c_void[src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    _mutator: &mut Mutator<R>,
    _constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]

impl NewFuzzed for *const c_void[src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    _mutator: &mut Mutator<R>,
    _constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]

Implementors

impl NewFuzzed for AsciiString[src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]

impl NewFuzzed for Utf8String[src]

type RangeType = usize

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]

impl<T, I> NewFuzzed for UnsafeEnum<T, I> where
    T: NewFuzzed,
    I: NewFuzzed<RangeType = I> + Bounded + Debug + Default, [src]

type RangeType = I

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Self[src]