Trait Mutation

pub trait Mutation<Value, M>: Sized
where
    Value: Clone + 'static,
    M: Mutator<Value>,
{
    type RandomStep: Clone;
    type Step: Clone;
    type Concrete<'a>
       where M: 'a,
             Value: 'a;
    type Revert: RevertMutation<Value, M>;

    // Required methods
    fn default_random_step(
        &self,
        mutator: &M,
        value: &Value,
    ) -> Option<Self::RandomStep>;
    fn random<'a>(
        mutator: &M,
        value: &Value,
        cache: &M::Cache,
        random_step: &Self::RandomStep,
        max_cplx: f64,
    ) -> Self::Concrete<'a>;
    fn default_step(
        &self,
        mutator: &M,
        value: &Value,
        cache: &M::Cache,
    ) -> Option<Self::Step>;
    fn from_step<'a>(
        mutator: &M,
        value: &Value,
        cache: &M::Cache,
        step: &'a mut Self::Step,
        subvalue_provider: &dyn SubValueProvider,
        max_cplx: f64,
    ) -> Option<Self::Concrete<'a>>;
    fn apply<'a>(
        mutation: Self::Concrete<'a>,
        mutator: &M,
        value: &mut Value,
        cache: &mut M::Cache,
        subvalue_provider: &dyn SubValueProvider,
        max_cplx: f64,
    ) -> (Self::Revert, f64);
}

Required Associated Types

type RandomStep: Clone

type Step: Clone

type Concrete<'a> where M: 'a, Value: 'a

type Revert: RevertMutation<Value, M>

Required Methods

fn default_random_step( &self, mutator: &M, value: &Value, ) -> Option<Self::RandomStep>

fn random<'a>( mutator: &M, value: &Value, cache: &M::Cache, random_step: &Self::RandomStep, max_cplx: f64, ) -> Self::Concrete<'a>

fn default_step( &self, mutator: &M, value: &Value, cache: &M::Cache, ) -> Option<Self::Step>

fn from_step<'a>( mutator: &M, value: &Value, cache: &M::Cache, step: &'a mut Self::Step, subvalue_provider: &dyn SubValueProvider, max_cplx: f64, ) -> Option<Self::Concrete<'a>>

fn apply<'a>( mutation: Self::Concrete<'a>, mutator: &M, value: &mut Value, cache: &mut M::Cache, subvalue_provider: &dyn SubValueProvider, max_cplx: f64, ) -> (Self::Revert, f64)

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T, M> Mutation<Vec<T>, VecMutator<T, M>> for Arbitrary

where T: Clone + 'static, M: Mutator<T>,

type RandomStep = ArbitraryStep

type Step = ArbitraryStep

type Concrete<'a> = ConcreteArbitrary<T>

type Revert = RevertArbitrary<T>

impl<T, M> Mutation<Vec<T>, VecMutator<T, M>> for CopyElement

where T: Clone + 'static, M: Mutator<T>,

type RandomStep = CopyElementRandomStep

type Step = CopyElementStep

type Concrete<'a> = ConcreteCopyElement<T>

type Revert = RevertCopyElement

impl<T, M> Mutation<Vec<T>, VecMutator<T, M>> for CrossoverInsertSlice

where T: Clone + 'static, M: Mutator<T>,

type RandomStep = !

type Step = CrossoverInsertSliceStep

type Concrete<'a> = ConcreteCrossoverInsertSlice<T>

type Revert = RevertCrossoverInsertSlice<<M as Mutator<T>>::UnmutateToken>

impl<T, M> Mutation<Vec<T>, VecMutator<T, M>> for CrossoverReplaceElement

where T: Clone + 'static, M: Mutator<T>,

type RandomStep = !

type Step = CrossoverReplaceElementStep<T>

type Concrete<'a> = ConcreteCrossoverReplaceElement<T>

type Revert = RevertCrossoverReplaceElement<T, <M as Mutator<T>>::UnmutateToken>

impl<T, M> Mutation<Vec<T>, VecMutator<T, M>> for InsertElement

where T: Clone + 'static, M: Mutator<T>,

type RandomStep = InsertElementRandomStep

type Step = InsertElementStep<<M as Mutator<T>>::ArbitraryStep>

type Concrete<'a> = ConcreteInsertElement<T>

type Revert = RevertInsertElement

impl<T, M> Mutation<Vec<T>, VecMutator<T, M>> for InsertManyElements

where T: Clone + 'static, M: Mutator<T>,

type RandomStep = InsertManyElementsStep

type Step = InsertManyElementsStep

type Concrete<'a> = ConcreteInsertManyElements<T>

type Revert = RevertInsertManyElements

impl<T, M> Mutation<Vec<T>, VecMutator<T, M>> for MutateElement

where T: Clone + 'static, M: Mutator<T>,

type RandomStep = MutateElementRandomStep

type Step = MutateElementStep<<M as Mutator<T>>::MutationStep>

type Concrete<'a> = ConcreteMutateElement<'a, <M as Mutator<T>>::MutationStep>

type Revert = RevertMutateElement<<M as Mutator<T>>::UnmutateToken>

impl<T, M> Mutation<Vec<T>, VecMutator<T, M>> for OnlyChooseLength

where T: Clone + 'static, M: Mutator<T>,

type RandomStep = OnlyChooseLengthRandomStep

type Step = OnlyChooseLengthStep

type Concrete<'a> = ConcreteOnlyChooseLength

type Revert = RevertOnlyChooseLength<T>

impl<T, M> Mutation<Vec<T>, VecMutator<T, M>> for Remove

where T: Clone + 'static, M: Mutator<T>,

type RandomStep = RemoveStep

type Step = RemoveStep

type Concrete<'a> = ConcreteRemove

type Revert = RevertRemove<T>

impl<T, M> Mutation<Vec<T>, VecMutator<T, M>> for RemoveAndInsertElement

where T: Clone + 'static, M: Mutator<T>,

type RandomStep = RemoveAndInsertElementRandomStep

type Step = RemoveAndInsertElementRandomStep

type Concrete<'a> = ConcreteRemoveAndInsertElement<T>

type Revert = RevertRemoveAndInsertElement<T>

impl<T, M> Mutation<Vec<T>, VecMutator<T, M>> for SwapElements

where T: Clone + 'static, M: Mutator<T>,

type RandomStep = SwapElementsStep

type Step = SwapElementsStep

type Concrete<'a> = ConcreteSwapElements

type Revert = RevertSwapElements

impl<T, M> Mutation<Vec<T>, VecMutator<T, M>> for VectorMutation

where T: Clone + 'static, M: Mutator<T>,

type RandomStep = VectorMutationRandomStep<T, M>

type Step = VectorMutationStep<T, M>

type Concrete<'a> = ConcreteVectorMutation<'a, T, M>

type Revert = RevertVectorMutation<T, M>

impl<Value, M> Mutation<Value, M> for NoMutation

where Value: Clone + 'static, M: Mutator<Value>,

type RandomStep = ()

type Step = ()

type Concrete<'a> = ()

type Revert = NoMutation