Trait fuzzcheck_mutators::TupleMutator

pub trait TupleMutator<T, TupleKind> where
    TupleKind: RefTypes,
    T: TupleStructure<TupleKind>, {
    type Cache: Clone;
    type MutationStep: Clone;
    type ArbitraryStep: Clone + Default;
    type UnmutateToken;
    fn complexity<'a>(
        &'a self, 
        value: TupleKind::Ref, 
        cache: &'a Self::Cache
    ) -> f64;
    fn cache_from_value<'a>(&'a self, value: TupleKind::Ref) -> Self::Cache;
    fn initial_step_from_value<'a>(
        &'a self, 
        value: TupleKind::Ref
    ) -> Self::MutationStep;
    fn max_complexity(&self) -> f64;
    fn min_complexity(&self) -> f64;
    fn ordered_arbitrary(
        &self, 
        step: &mut Self::ArbitraryStep, 
        max_cplx: f64
    ) -> Option<(T, Self::Cache)>;
    fn random_arbitrary(&self, max_cplx: f64) -> (T, Self::Cache);
    fn ordered_mutate<'a>(
        &'a self, 
        value: TupleKind::Mut, 
        cache: &'a mut Self::Cache, 
        step: &'a mut Self::MutationStep, 
        max_cplx: f64
    ) -> Option<Self::UnmutateToken>;
    fn random_mutate<'a>(
        &'a self, 
        value: TupleKind::Mut, 
        cache: &'a mut Self::Cache, 
        max_cplx: f64
    ) -> Self::UnmutateToken;
    fn unmutate<'a>(
        &'a self, 
        value: TupleKind::Mut, 
        cache: &'a mut Self::Cache, 
        t: Self::UnmutateToken
    );
}

Associated Types

type Cache: Clone

type MutationStep: Clone

type ArbitraryStep: Clone + Default

type UnmutateToken

Loading content...

Required methods

fn complexity<'a>(
    &'a self,
    value: TupleKind::Ref,
    cache: &'a Self::Cache
) -> f64

fn cache_from_value<'a>(&'a self, value: TupleKind::Ref) -> Self::Cache

fn initial_step_from_value<'a>(
    &'a self,
    value: TupleKind::Ref
) -> Self::MutationStep

fn max_complexity(&self) -> f64

fn min_complexity(&self) -> f64

fn ordered_arbitrary(
    &self,
    step: &mut Self::ArbitraryStep,
    max_cplx: f64
) -> Option<(T, Self::Cache)>

fn random_arbitrary(&self, max_cplx: f64) -> (T, Self::Cache)

fn ordered_mutate<'a>(
    &'a self,
    value: TupleKind::Mut,
    cache: &'a mut Self::Cache,
    step: &'a mut Self::MutationStep,
    max_cplx: f64
) -> Option<Self::UnmutateToken>

fn random_mutate<'a>(
    &'a self,
    value: TupleKind::Mut,
    cache: &'a mut Self::Cache,
    max_cplx: f64
) -> Self::UnmutateToken

fn unmutate<'a>(
    &'a self,
    value: TupleKind::Mut,
    cache: &'a mut Self::Cache,
    t: Self::UnmutateToken
)

Loading content...

Implementors

impl<T, M> TupleMutator<T, Tuple1<T>> for Tuple1Mutator<T, M> where
    T: Clone + 'static,
    M: Mutator<T>, 

type Cache = M::Cache

type MutationStep = M::MutationStep

type ArbitraryStep = M::ArbitraryStep

type UnmutateToken = M::UnmutateToken

fn complexity<'a>(&'a self, value: &'a T, cache: &'a Self::Cache) -> f64

fn cache_from_value<'a>(&'a self, value: &'a T) -> Self::Cache

fn initial_step_from_value<'a>(&'a self, value: &'a T) -> Self::MutationStep

fn max_complexity(&self) -> f64

fn min_complexity(&self) -> f64

fn ordered_arbitrary(
    &self,
    step: &mut Self::ArbitraryStep,
    max_cplx: f64
) -> Option<(T, Self::Cache)>

fn random_arbitrary(&self, max_cplx: f64) -> (T, Self::Cache)

fn ordered_mutate<'a>(
    &'a self,
    value: &'a mut T,
    cache: &'a mut Self::Cache,
    step: &'a mut Self::MutationStep,
    max_cplx: f64
) -> Option<Self::UnmutateToken>

fn random_mutate<'a>(
    &'a self,
    value: &'a mut T,
    cache: &'a mut Self::Cache,
    max_cplx: f64
) -> Self::UnmutateToken

fn unmutate<'a>(
    &'a self,
    value: &'a mut T,
    cache: &'a mut Self::Cache,
    t: Self::UnmutateToken
)

impl<T, T0, T1, M0, M1> TupleMutator<T, Tuple2<T0, T1>> for Tuple2Mutator<T0, T1, M0, M1> where
    T: Clone,
    T0: Clone + 'static,
    M0: Mutator<T0>,
    T1: Clone + 'static,
    M1: Mutator<T1>,
    T: TupleStructure<Tuple2<T0, T1>>, 

type Cache = Cache<<M0 as Mutator<T0>>::Cache, <M1 as Mutator<T1>>::Cache>

type MutationStep = MutationStep<<M0 as Mutator<T0>>::MutationStep, <M1 as Mutator<T1>>::MutationStep>

type ArbitraryStep = ArbitraryStep<<M0 as Mutator<T0>>::ArbitraryStep, <M1 as Mutator<T1>>::ArbitraryStep>

type UnmutateToken = UnmutateToken<<M0 as Mutator<T0>>::UnmutateToken, <M1 as Mutator<T1>>::UnmutateToken>

fn max_complexity(&self) -> f64

fn min_complexity(&self) -> f64

fn complexity<'a>(
    &'a self,
    _value: (&'a T0, &'a T1),
    cache: &'a Self::Cache
) -> f64

fn cache_from_value<'a>(&'a self, value: (&'a T0, &'a T1)) -> Self::Cache

fn initial_step_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1)
) -> Self::MutationStep

fn ordered_arbitrary(
    &self,
    step: &mut Self::ArbitraryStep,
    max_cplx: f64
) -> Option<(T, Self::Cache)>

fn random_arbitrary(&self, max_cplx: f64) -> (T, Self::Cache)

fn ordered_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1),
    cache: &'a mut Self::Cache,
    step: &'a mut Self::MutationStep,
    max_cplx: f64
) -> Option<Self::UnmutateToken>

fn random_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1),
    cache: &'a mut Self::Cache,
    max_cplx: f64
) -> Self::UnmutateToken

fn unmutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1),
    cache: &'a mut Self::Cache,
    t: Self::UnmutateToken
)

impl<T, T0, T1, T2, M0, M1, M2> TupleMutator<T, Tuple3<T0, T1, T2>> for Tuple3Mutator<T0, T1, T2, M0, M1, M2> where
    T: Clone,
    T0: Clone + 'static,
    M0: Mutator<T0>,
    T1: Clone + 'static,
    M1: Mutator<T1>,
    T2: Clone + 'static,
    M2: Mutator<T2>,
    T: TupleStructure<Tuple3<T0, T1, T2>>, 

type Cache = Cache<<M0 as Mutator<T0>>::Cache, <M1 as Mutator<T1>>::Cache, <M2 as Mutator<T2>>::Cache>

type MutationStep = MutationStep<<M0 as Mutator<T0>>::MutationStep, <M1 as Mutator<T1>>::MutationStep, <M2 as Mutator<T2>>::MutationStep>

type ArbitraryStep = ArbitraryStep<<M0 as Mutator<T0>>::ArbitraryStep, <M1 as Mutator<T1>>::ArbitraryStep, <M2 as Mutator<T2>>::ArbitraryStep>

type UnmutateToken = UnmutateToken<<M0 as Mutator<T0>>::UnmutateToken, <M1 as Mutator<T1>>::UnmutateToken, <M2 as Mutator<T2>>::UnmutateToken>

fn max_complexity(&self) -> f64

fn min_complexity(&self) -> f64

fn complexity<'a>(
    &'a self,
    _value: (&'a T0, &'a T1, &'a T2),
    cache: &'a Self::Cache
) -> f64

fn cache_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2)
) -> Self::Cache

fn initial_step_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2)
) -> Self::MutationStep

fn ordered_arbitrary(
    &self,
    step: &mut Self::ArbitraryStep,
    max_cplx: f64
) -> Option<(T, Self::Cache)>

fn random_arbitrary(&self, max_cplx: f64) -> (T, Self::Cache)

fn ordered_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2),
    cache: &'a mut Self::Cache,
    step: &'a mut Self::MutationStep,
    max_cplx: f64
) -> Option<Self::UnmutateToken>

fn random_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2),
    cache: &'a mut Self::Cache,
    max_cplx: f64
) -> Self::UnmutateToken

fn unmutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2),
    cache: &'a mut Self::Cache,
    t: Self::UnmutateToken
)

impl<T, T0, T1, T2, T3, M0, M1, M2, M3> TupleMutator<T, Tuple4<T0, T1, T2, T3>> for Tuple4Mutator<T0, T1, T2, T3, M0, M1, M2, M3> where
    T: Clone,
    T0: Clone + 'static,
    M0: Mutator<T0>,
    T1: Clone + 'static,
    M1: Mutator<T1>,
    T2: Clone + 'static,
    M2: Mutator<T2>,
    T3: Clone + 'static,
    M3: Mutator<T3>,
    T: TupleStructure<Tuple4<T0, T1, T2, T3>>, 

type Cache = Cache<<M0 as Mutator<T0>>::Cache, <M1 as Mutator<T1>>::Cache, <M2 as Mutator<T2>>::Cache, <M3 as Mutator<T3>>::Cache>

type MutationStep = MutationStep<<M0 as Mutator<T0>>::MutationStep, <M1 as Mutator<T1>>::MutationStep, <M2 as Mutator<T2>>::MutationStep, <M3 as Mutator<T3>>::MutationStep>

type ArbitraryStep = ArbitraryStep<<M0 as Mutator<T0>>::ArbitraryStep, <M1 as Mutator<T1>>::ArbitraryStep, <M2 as Mutator<T2>>::ArbitraryStep, <M3 as Mutator<T3>>::ArbitraryStep>

type UnmutateToken = UnmutateToken<<M0 as Mutator<T0>>::UnmutateToken, <M1 as Mutator<T1>>::UnmutateToken, <M2 as Mutator<T2>>::UnmutateToken, <M3 as Mutator<T3>>::UnmutateToken>

fn max_complexity(&self) -> f64

fn min_complexity(&self) -> f64

fn complexity<'a>(
    &'a self,
    _value: (&'a T0, &'a T1, &'a T2, &'a T3),
    cache: &'a Self::Cache
) -> f64

fn cache_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2, &'a T3)
) -> Self::Cache

fn initial_step_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2, &'a T3)
) -> Self::MutationStep

fn ordered_arbitrary(
    &self,
    step: &mut Self::ArbitraryStep,
    max_cplx: f64
) -> Option<(T, Self::Cache)>

fn random_arbitrary(&self, max_cplx: f64) -> (T, Self::Cache)

fn ordered_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3),
    cache: &'a mut Self::Cache,
    step: &'a mut Self::MutationStep,
    max_cplx: f64
) -> Option<Self::UnmutateToken>

fn random_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3),
    cache: &'a mut Self::Cache,
    max_cplx: f64
) -> Self::UnmutateToken

fn unmutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3),
    cache: &'a mut Self::Cache,
    t: Self::UnmutateToken
)

impl<T, T0, T1, T2, T3, T4, M0, M1, M2, M3, M4> TupleMutator<T, Tuple5<T0, T1, T2, T3, T4>> for Tuple5Mutator<T0, T1, T2, T3, T4, M0, M1, M2, M3, M4> where
    T: Clone,
    T0: Clone + 'static,
    M0: Mutator<T0>,
    T1: Clone + 'static,
    M1: Mutator<T1>,
    T2: Clone + 'static,
    M2: Mutator<T2>,
    T3: Clone + 'static,
    M3: Mutator<T3>,
    T4: Clone + 'static,
    M4: Mutator<T4>,
    T: TupleStructure<Tuple5<T0, T1, T2, T3, T4>>, 

type Cache = Cache<<M0 as Mutator<T0>>::Cache, <M1 as Mutator<T1>>::Cache, <M2 as Mutator<T2>>::Cache, <M3 as Mutator<T3>>::Cache, <M4 as Mutator<T4>>::Cache>

type MutationStep = MutationStep<<M0 as Mutator<T0>>::MutationStep, <M1 as Mutator<T1>>::MutationStep, <M2 as Mutator<T2>>::MutationStep, <M3 as Mutator<T3>>::MutationStep, <M4 as Mutator<T4>>::MutationStep>

type ArbitraryStep = ArbitraryStep<<M0 as Mutator<T0>>::ArbitraryStep, <M1 as Mutator<T1>>::ArbitraryStep, <M2 as Mutator<T2>>::ArbitraryStep, <M3 as Mutator<T3>>::ArbitraryStep, <M4 as Mutator<T4>>::ArbitraryStep>

type UnmutateToken = UnmutateToken<<M0 as Mutator<T0>>::UnmutateToken, <M1 as Mutator<T1>>::UnmutateToken, <M2 as Mutator<T2>>::UnmutateToken, <M3 as Mutator<T3>>::UnmutateToken, <M4 as Mutator<T4>>::UnmutateToken>

fn max_complexity(&self) -> f64

fn min_complexity(&self) -> f64

fn complexity<'a>(
    &'a self,
    _value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4),
    cache: &'a Self::Cache
) -> f64

fn cache_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4)
) -> Self::Cache

fn initial_step_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4)
) -> Self::MutationStep

fn ordered_arbitrary(
    &self,
    step: &mut Self::ArbitraryStep,
    max_cplx: f64
) -> Option<(T, Self::Cache)>

fn random_arbitrary(&self, max_cplx: f64) -> (T, Self::Cache)

fn ordered_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4),
    cache: &'a mut Self::Cache,
    step: &'a mut Self::MutationStep,
    max_cplx: f64
) -> Option<Self::UnmutateToken>

fn random_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4),
    cache: &'a mut Self::Cache,
    max_cplx: f64
) -> Self::UnmutateToken

fn unmutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4),
    cache: &'a mut Self::Cache,
    t: Self::UnmutateToken
)

impl<T, T0, T1, T2, T3, T4, T5, M0, M1, M2, M3, M4, M5> TupleMutator<T, Tuple6<T0, T1, T2, T3, T4, T5>> for Tuple6Mutator<T0, T1, T2, T3, T4, T5, M0, M1, M2, M3, M4, M5> where
    T: Clone,
    T0: Clone + 'static,
    M0: Mutator<T0>,
    T1: Clone + 'static,
    M1: Mutator<T1>,
    T2: Clone + 'static,
    M2: Mutator<T2>,
    T3: Clone + 'static,
    M3: Mutator<T3>,
    T4: Clone + 'static,
    M4: Mutator<T4>,
    T5: Clone + 'static,
    M5: Mutator<T5>,
    T: TupleStructure<Tuple6<T0, T1, T2, T3, T4, T5>>, 

type Cache = Cache<<M0 as Mutator<T0>>::Cache, <M1 as Mutator<T1>>::Cache, <M2 as Mutator<T2>>::Cache, <M3 as Mutator<T3>>::Cache, <M4 as Mutator<T4>>::Cache, <M5 as Mutator<T5>>::Cache>

type MutationStep = MutationStep<<M0 as Mutator<T0>>::MutationStep, <M1 as Mutator<T1>>::MutationStep, <M2 as Mutator<T2>>::MutationStep, <M3 as Mutator<T3>>::MutationStep, <M4 as Mutator<T4>>::MutationStep, <M5 as Mutator<T5>>::MutationStep>

type ArbitraryStep = ArbitraryStep<<M0 as Mutator<T0>>::ArbitraryStep, <M1 as Mutator<T1>>::ArbitraryStep, <M2 as Mutator<T2>>::ArbitraryStep, <M3 as Mutator<T3>>::ArbitraryStep, <M4 as Mutator<T4>>::ArbitraryStep, <M5 as Mutator<T5>>::ArbitraryStep>

type UnmutateToken = UnmutateToken<<M0 as Mutator<T0>>::UnmutateToken, <M1 as Mutator<T1>>::UnmutateToken, <M2 as Mutator<T2>>::UnmutateToken, <M3 as Mutator<T3>>::UnmutateToken, <M4 as Mutator<T4>>::UnmutateToken, <M5 as Mutator<T5>>::UnmutateToken>

fn max_complexity(&self) -> f64

fn min_complexity(&self) -> f64

fn complexity<'a>(
    &'a self,
    _value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5),
    cache: &'a Self::Cache
) -> f64

fn cache_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5)
) -> Self::Cache

fn initial_step_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5)
) -> Self::MutationStep

fn ordered_arbitrary(
    &self,
    step: &mut Self::ArbitraryStep,
    max_cplx: f64
) -> Option<(T, Self::Cache)>

fn random_arbitrary(&self, max_cplx: f64) -> (T, Self::Cache)

fn ordered_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5),
    cache: &'a mut Self::Cache,
    step: &'a mut Self::MutationStep,
    max_cplx: f64
) -> Option<Self::UnmutateToken>

fn random_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5),
    cache: &'a mut Self::Cache,
    max_cplx: f64
) -> Self::UnmutateToken

fn unmutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5),
    cache: &'a mut Self::Cache,
    t: Self::UnmutateToken
)

impl<T, T0, T1, T2, T3, T4, T5, T6, M0, M1, M2, M3, M4, M5, M6> TupleMutator<T, Tuple7<T0, T1, T2, T3, T4, T5, T6>> for Tuple7Mutator<T0, T1, T2, T3, T4, T5, T6, M0, M1, M2, M3, M4, M5, M6> where
    T: Clone,
    T0: Clone + 'static,
    M0: Mutator<T0>,
    T1: Clone + 'static,
    M1: Mutator<T1>,
    T2: Clone + 'static,
    M2: Mutator<T2>,
    T3: Clone + 'static,
    M3: Mutator<T3>,
    T4: Clone + 'static,
    M4: Mutator<T4>,
    T5: Clone + 'static,
    M5: Mutator<T5>,
    T6: Clone + 'static,
    M6: Mutator<T6>,
    T: TupleStructure<Tuple7<T0, T1, T2, T3, T4, T5, T6>>, 

type Cache = Cache<<M0 as Mutator<T0>>::Cache, <M1 as Mutator<T1>>::Cache, <M2 as Mutator<T2>>::Cache, <M3 as Mutator<T3>>::Cache, <M4 as Mutator<T4>>::Cache, <M5 as Mutator<T5>>::Cache, <M6 as Mutator<T6>>::Cache>

type MutationStep = MutationStep<<M0 as Mutator<T0>>::MutationStep, <M1 as Mutator<T1>>::MutationStep, <M2 as Mutator<T2>>::MutationStep, <M3 as Mutator<T3>>::MutationStep, <M4 as Mutator<T4>>::MutationStep, <M5 as Mutator<T5>>::MutationStep, <M6 as Mutator<T6>>::MutationStep>

type ArbitraryStep = ArbitraryStep<<M0 as Mutator<T0>>::ArbitraryStep, <M1 as Mutator<T1>>::ArbitraryStep, <M2 as Mutator<T2>>::ArbitraryStep, <M3 as Mutator<T3>>::ArbitraryStep, <M4 as Mutator<T4>>::ArbitraryStep, <M5 as Mutator<T5>>::ArbitraryStep, <M6 as Mutator<T6>>::ArbitraryStep>

type UnmutateToken = UnmutateToken<<M0 as Mutator<T0>>::UnmutateToken, <M1 as Mutator<T1>>::UnmutateToken, <M2 as Mutator<T2>>::UnmutateToken, <M3 as Mutator<T3>>::UnmutateToken, <M4 as Mutator<T4>>::UnmutateToken, <M5 as Mutator<T5>>::UnmutateToken, <M6 as Mutator<T6>>::UnmutateToken>

fn max_complexity(&self) -> f64

fn min_complexity(&self) -> f64

fn complexity<'a>(
    &'a self,
    _value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6),
    cache: &'a Self::Cache
) -> f64

fn cache_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6)
) -> Self::Cache

fn initial_step_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6)
) -> Self::MutationStep

fn ordered_arbitrary(
    &self,
    step: &mut Self::ArbitraryStep,
    max_cplx: f64
) -> Option<(T, Self::Cache)>

fn random_arbitrary(&self, max_cplx: f64) -> (T, Self::Cache)

fn ordered_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6),
    cache: &'a mut Self::Cache,
    step: &'a mut Self::MutationStep,
    max_cplx: f64
) -> Option<Self::UnmutateToken>

fn random_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6),
    cache: &'a mut Self::Cache,
    max_cplx: f64
) -> Self::UnmutateToken

fn unmutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6),
    cache: &'a mut Self::Cache,
    t: Self::UnmutateToken
)

impl<T, T0, T1, T2, T3, T4, T5, T6, T7, M0, M1, M2, M3, M4, M5, M6, M7> TupleMutator<T, Tuple8<T0, T1, T2, T3, T4, T5, T6, T7>> for Tuple8Mutator<T0, T1, T2, T3, T4, T5, T6, T7, M0, M1, M2, M3, M4, M5, M6, M7> where
    T: Clone,
    T0: Clone + 'static,
    M0: Mutator<T0>,
    T1: Clone + 'static,
    M1: Mutator<T1>,
    T2: Clone + 'static,
    M2: Mutator<T2>,
    T3: Clone + 'static,
    M3: Mutator<T3>,
    T4: Clone + 'static,
    M4: Mutator<T4>,
    T5: Clone + 'static,
    M5: Mutator<T5>,
    T6: Clone + 'static,
    M6: Mutator<T6>,
    T7: Clone + 'static,
    M7: Mutator<T7>,
    T: TupleStructure<Tuple8<T0, T1, T2, T3, T4, T5, T6, T7>>, 

type Cache = Cache<<M0 as Mutator<T0>>::Cache, <M1 as Mutator<T1>>::Cache, <M2 as Mutator<T2>>::Cache, <M3 as Mutator<T3>>::Cache, <M4 as Mutator<T4>>::Cache, <M5 as Mutator<T5>>::Cache, <M6 as Mutator<T6>>::Cache, <M7 as Mutator<T7>>::Cache>

type MutationStep = MutationStep<<M0 as Mutator<T0>>::MutationStep, <M1 as Mutator<T1>>::MutationStep, <M2 as Mutator<T2>>::MutationStep, <M3 as Mutator<T3>>::MutationStep, <M4 as Mutator<T4>>::MutationStep, <M5 as Mutator<T5>>::MutationStep, <M6 as Mutator<T6>>::MutationStep, <M7 as Mutator<T7>>::MutationStep>

type ArbitraryStep = ArbitraryStep<<M0 as Mutator<T0>>::ArbitraryStep, <M1 as Mutator<T1>>::ArbitraryStep, <M2 as Mutator<T2>>::ArbitraryStep, <M3 as Mutator<T3>>::ArbitraryStep, <M4 as Mutator<T4>>::ArbitraryStep, <M5 as Mutator<T5>>::ArbitraryStep, <M6 as Mutator<T6>>::ArbitraryStep, <M7 as Mutator<T7>>::ArbitraryStep>

type UnmutateToken = UnmutateToken<<M0 as Mutator<T0>>::UnmutateToken, <M1 as Mutator<T1>>::UnmutateToken, <M2 as Mutator<T2>>::UnmutateToken, <M3 as Mutator<T3>>::UnmutateToken, <M4 as Mutator<T4>>::UnmutateToken, <M5 as Mutator<T5>>::UnmutateToken, <M6 as Mutator<T6>>::UnmutateToken, <M7 as Mutator<T7>>::UnmutateToken>

fn max_complexity(&self) -> f64

fn min_complexity(&self) -> f64

fn complexity<'a>(
    &'a self,
    _value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7),
    cache: &'a Self::Cache
) -> f64

fn cache_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7)
) -> Self::Cache

fn initial_step_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7)
) -> Self::MutationStep

fn ordered_arbitrary(
    &self,
    step: &mut Self::ArbitraryStep,
    max_cplx: f64
) -> Option<(T, Self::Cache)>

fn random_arbitrary(&self, max_cplx: f64) -> (T, Self::Cache)

fn ordered_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6, &'a mut T7),
    cache: &'a mut Self::Cache,
    step: &'a mut Self::MutationStep,
    max_cplx: f64
) -> Option<Self::UnmutateToken>

fn random_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6, &'a mut T7),
    cache: &'a mut Self::Cache,
    max_cplx: f64
) -> Self::UnmutateToken

fn unmutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6, &'a mut T7),
    cache: &'a mut Self::Cache,
    t: Self::UnmutateToken
)

impl<T, T0, T1, T2, T3, T4, T5, T6, T7, T8, M0, M1, M2, M3, M4, M5, M6, M7, M8> TupleMutator<T, Tuple9<T0, T1, T2, T3, T4, T5, T6, T7, T8>> for Tuple9Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, M0, M1, M2, M3, M4, M5, M6, M7, M8> where
    T: Clone,
    T0: Clone + 'static,
    M0: Mutator<T0>,
    T1: Clone + 'static,
    M1: Mutator<T1>,
    T2: Clone + 'static,
    M2: Mutator<T2>,
    T3: Clone + 'static,
    M3: Mutator<T3>,
    T4: Clone + 'static,
    M4: Mutator<T4>,
    T5: Clone + 'static,
    M5: Mutator<T5>,
    T6: Clone + 'static,
    M6: Mutator<T6>,
    T7: Clone + 'static,
    M7: Mutator<T7>,
    T8: Clone + 'static,
    M8: Mutator<T8>,
    T: TupleStructure<Tuple9<T0, T1, T2, T3, T4, T5, T6, T7, T8>>, 

type Cache = Cache<<M0 as Mutator<T0>>::Cache, <M1 as Mutator<T1>>::Cache, <M2 as Mutator<T2>>::Cache, <M3 as Mutator<T3>>::Cache, <M4 as Mutator<T4>>::Cache, <M5 as Mutator<T5>>::Cache, <M6 as Mutator<T6>>::Cache, <M7 as Mutator<T7>>::Cache, <M8 as Mutator<T8>>::Cache>

type MutationStep = MutationStep<<M0 as Mutator<T0>>::MutationStep, <M1 as Mutator<T1>>::MutationStep, <M2 as Mutator<T2>>::MutationStep, <M3 as Mutator<T3>>::MutationStep, <M4 as Mutator<T4>>::MutationStep, <M5 as Mutator<T5>>::MutationStep, <M6 as Mutator<T6>>::MutationStep, <M7 as Mutator<T7>>::MutationStep, <M8 as Mutator<T8>>::MutationStep>

type ArbitraryStep = ArbitraryStep<<M0 as Mutator<T0>>::ArbitraryStep, <M1 as Mutator<T1>>::ArbitraryStep, <M2 as Mutator<T2>>::ArbitraryStep, <M3 as Mutator<T3>>::ArbitraryStep, <M4 as Mutator<T4>>::ArbitraryStep, <M5 as Mutator<T5>>::ArbitraryStep, <M6 as Mutator<T6>>::ArbitraryStep, <M7 as Mutator<T7>>::ArbitraryStep, <M8 as Mutator<T8>>::ArbitraryStep>

type UnmutateToken = UnmutateToken<<M0 as Mutator<T0>>::UnmutateToken, <M1 as Mutator<T1>>::UnmutateToken, <M2 as Mutator<T2>>::UnmutateToken, <M3 as Mutator<T3>>::UnmutateToken, <M4 as Mutator<T4>>::UnmutateToken, <M5 as Mutator<T5>>::UnmutateToken, <M6 as Mutator<T6>>::UnmutateToken, <M7 as Mutator<T7>>::UnmutateToken, <M8 as Mutator<T8>>::UnmutateToken>

fn max_complexity(&self) -> f64

fn min_complexity(&self) -> f64

fn complexity<'a>(
    &'a self,
    _value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7, &'a T8),
    cache: &'a Self::Cache
) -> f64

fn cache_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7, &'a T8)
) -> Self::Cache

fn initial_step_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7, &'a T8)
) -> Self::MutationStep

fn ordered_arbitrary(
    &self,
    step: &mut Self::ArbitraryStep,
    max_cplx: f64
) -> Option<(T, Self::Cache)>

fn random_arbitrary(&self, max_cplx: f64) -> (T, Self::Cache)

fn ordered_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6, &'a mut T7, &'a mut T8),
    cache: &'a mut Self::Cache,
    step: &'a mut Self::MutationStep,
    max_cplx: f64
) -> Option<Self::UnmutateToken>

fn random_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6, &'a mut T7, &'a mut T8),
    cache: &'a mut Self::Cache,
    max_cplx: f64
) -> Self::UnmutateToken

fn unmutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6, &'a mut T7, &'a mut T8),
    cache: &'a mut Self::Cache,
    t: Self::UnmutateToken
)

impl<T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> TupleMutator<T, Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>> for Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> where
    T: Clone,
    T0: Clone + 'static,
    M0: Mutator<T0>,
    T1: Clone + 'static,
    M1: Mutator<T1>,
    T2: Clone + 'static,
    M2: Mutator<T2>,
    T3: Clone + 'static,
    M3: Mutator<T3>,
    T4: Clone + 'static,
    M4: Mutator<T4>,
    T5: Clone + 'static,
    M5: Mutator<T5>,
    T6: Clone + 'static,
    M6: Mutator<T6>,
    T7: Clone + 'static,
    M7: Mutator<T7>,
    T8: Clone + 'static,
    M8: Mutator<T8>,
    T9: Clone + 'static,
    M9: Mutator<T9>,
    T: TupleStructure<Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>>, 

type Cache = Cache<<M0 as Mutator<T0>>::Cache, <M1 as Mutator<T1>>::Cache, <M2 as Mutator<T2>>::Cache, <M3 as Mutator<T3>>::Cache, <M4 as Mutator<T4>>::Cache, <M5 as Mutator<T5>>::Cache, <M6 as Mutator<T6>>::Cache, <M7 as Mutator<T7>>::Cache, <M8 as Mutator<T8>>::Cache, <M9 as Mutator<T9>>::Cache>

type MutationStep = MutationStep<<M0 as Mutator<T0>>::MutationStep, <M1 as Mutator<T1>>::MutationStep, <M2 as Mutator<T2>>::MutationStep, <M3 as Mutator<T3>>::MutationStep, <M4 as Mutator<T4>>::MutationStep, <M5 as Mutator<T5>>::MutationStep, <M6 as Mutator<T6>>::MutationStep, <M7 as Mutator<T7>>::MutationStep, <M8 as Mutator<T8>>::MutationStep, <M9 as Mutator<T9>>::MutationStep>

type ArbitraryStep = ArbitraryStep<<M0 as Mutator<T0>>::ArbitraryStep, <M1 as Mutator<T1>>::ArbitraryStep, <M2 as Mutator<T2>>::ArbitraryStep, <M3 as Mutator<T3>>::ArbitraryStep, <M4 as Mutator<T4>>::ArbitraryStep, <M5 as Mutator<T5>>::ArbitraryStep, <M6 as Mutator<T6>>::ArbitraryStep, <M7 as Mutator<T7>>::ArbitraryStep, <M8 as Mutator<T8>>::ArbitraryStep, <M9 as Mutator<T9>>::ArbitraryStep>

type UnmutateToken = UnmutateToken<<M0 as Mutator<T0>>::UnmutateToken, <M1 as Mutator<T1>>::UnmutateToken, <M2 as Mutator<T2>>::UnmutateToken, <M3 as Mutator<T3>>::UnmutateToken, <M4 as Mutator<T4>>::UnmutateToken, <M5 as Mutator<T5>>::UnmutateToken, <M6 as Mutator<T6>>::UnmutateToken, <M7 as Mutator<T7>>::UnmutateToken, <M8 as Mutator<T8>>::UnmutateToken, <M9 as Mutator<T9>>::UnmutateToken>

fn max_complexity(&self) -> f64

fn min_complexity(&self) -> f64

fn complexity<'a>(
    &'a self,
    _value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7, &'a T8, &'a T9),
    cache: &'a Self::Cache
) -> f64

fn cache_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7, &'a T8, &'a T9)
) -> Self::Cache

fn initial_step_from_value<'a>(
    &'a self,
    value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7, &'a T8, &'a T9)
) -> Self::MutationStep

fn ordered_arbitrary(
    &self,
    step: &mut Self::ArbitraryStep,
    max_cplx: f64
) -> Option<(T, Self::Cache)>

fn random_arbitrary(&self, max_cplx: f64) -> (T, Self::Cache)

fn ordered_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6, &'a mut T7, &'a mut T8, &'a mut T9),
    cache: &'a mut Self::Cache,
    step: &'a mut Self::MutationStep,
    max_cplx: f64
) -> Option<Self::UnmutateToken>

fn random_mutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6, &'a mut T7, &'a mut T8, &'a mut T9),
    cache: &'a mut Self::Cache,
    max_cplx: f64
) -> Self::UnmutateToken

fn unmutate<'a>(
    &'a self,
    value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6, &'a mut T7, &'a mut T8, &'a mut T9),
    cache: &'a mut Self::Cache,
    t: Self::UnmutateToken
)

impl<T, U, M> TupleMutator<U, Wrapped<T>> for Tuple1Mutator<T, M> where
    U: TupleStructure<Wrapped<T>>,
    T: Clone + 'static,
    M: Mutator<T>, 

type Cache = M::Cache

type MutationStep = M::MutationStep

type ArbitraryStep = M::ArbitraryStep

type UnmutateToken = M::UnmutateToken

fn complexity<'a>(&'a self, value: &'a T, cache: &'a Self::Cache) -> f64

fn cache_from_value<'a>(&'a self, value: &'a T) -> Self::Cache

fn initial_step_from_value<'a>(&'a self, value: &'a T) -> Self::MutationStep

fn max_complexity(&self) -> f64

fn min_complexity(&self) -> f64

fn ordered_arbitrary(
    &self,
    step: &mut Self::ArbitraryStep,
    max_cplx: f64
) -> Option<(U, Self::Cache)>

fn random_arbitrary(&self, max_cplx: f64) -> (U, Self::Cache)

fn ordered_mutate<'a>(
    &'a self,
    value: &'a mut T,
    cache: &'a mut Self::Cache,
    step: &'a mut Self::MutationStep,
    max_cplx: f64
) -> Option<Self::UnmutateToken>

fn random_mutate<'a>(
    &'a self,
    value: &'a mut T,
    cache: &'a mut Self::Cache,
    max_cplx: f64
) -> Self::UnmutateToken

fn unmutate<'a>(
    &'a self,
    value: &'a mut T,
    cache: &'a mut Self::Cache,
    t: Self::UnmutateToken
)

Loading content...