Struct Wrapped

pub struct Wrapped<T: 'static> { /* private fields */ }

Trait Implementations

impl<T: 'static> RefTypes for Wrapped<T>

type Owned = T

type Ref<'a> = &'a T

type Mut<'a> = &'a mut T

fn get_ref_from_mut<'a>(v: &'a Self::Mut<'a>) -> Self::Ref<'a>

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 as Mutator<T>>::Cache

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

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

type UnmutateToken = <M as Mutator<T>>::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, )