Trait proptest::strategy::ValueTree

pub trait ValueTree {
    type Value: Debug;
    fn current(&self) -> Self::Value;
    fn simplify(&mut self) -> bool;
    fn complicate(&mut self) -> bool;
}

A generated value and its associated shrinker.

Conceptually, a ValueTree represents a spectrum between a "minimally complex" value and a starting, randomly-chosen value. For values such as numbers, this can be thought of as a simple binary search, and this is how the ValueTree state machine is defined.

The ValueTree state machine notionally has three fields: low, current, and high. Initially, low is the "minimally complex" value for the type, and high and current are both the initially chosen value. It can be queried for its current state. When shrinking, the controlling code tries simplifying the value one step. If the test failure still happens with the simplified value, further simplification occurs. Otherwise, the code steps back up towards the prior complexity.

The main invariants here are that the "high" value always corresponds to a failing test case, and that repeated calls to complicate() will return false only once the "current" value has returned to what it was before the last call to simplify().

While it would be possible for default do-nothing implementations of simplify() and complicate() to be provided, this was not done deliberately since the majority of strategies will want to define their own shrinking anyway, and the minority that do not must call it out explicitly by their own implementation.

Associated Types

type Value: Debug

The type of the value produced by this ValueTree.

Loading content...

Required methods

fn current(&self) -> Self::Value

Returns the current value.

fn simplify(&mut self) -> bool

Attempts to simplify the current value. Notionally, this sets the "high" value to the current value, and the current value to a "halfway point" between high and low, rounding towards low.

Returns whether any state changed as a result of this call. This does not necessarily imply that the value of current() has changed, since in the most general case, it is not possible for an implementation to determine this.

This call needs to correctly handle being called even immediately after it had been called previously and returned false.

fn complicate(&mut self) -> bool

Attempts to partially undo the last simplification. Notionally, this sets the "low" value to one plus the current value, and the current value to a "halfway point" between high and the new low, rounding towards low.

Returns whether any state changed as a result of this call. This does not necessarily imply that the value of current() has changed, since in the most general case, it is not possible for an implementation to determine this.

It is usually expected that, immediately after a call to simplify() which returns true, this call will itself return true. However, this is not always the case; in some strategies, particularly those that use some form of rejection sampling, the act of trying to simplify may change the state such that simplify() returns true, yet ultimately left the resulting value unchanged, in which case there is nothing left to complicate.

This call does not need to gracefully handle being called before simplify() was ever called, but does need to correctly handle being called even immediately after it had been called previously and returned false.

Loading content...

Implementations on Foreign Types

impl<T: ValueTree + ?Sized> ValueTree for Box<T>

type Value = T::Value

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

Loading content...

Implementors

impl ValueTree for BoolValueTree

type Value = bool

fn current(&self) -> bool

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl ValueTree for CharValueTree

type Value = char

fn current(&self) -> char

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl ValueTree for proptest::num::f32::BinarySearch

type Value = f32

fn current(&self) -> f32

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl ValueTree for proptest::num::f64::BinarySearch

type Value = f64

fn current(&self) -> f64

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl ValueTree for proptest::num::i8::BinarySearch

type Value = i8

fn current(&self) -> i8

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl ValueTree for proptest::num::i16::BinarySearch

type Value = i16

fn current(&self) -> i16

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl ValueTree for proptest::num::i32::BinarySearch

type Value = i32

fn current(&self) -> i32

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl ValueTree for proptest::num::i64::BinarySearch

type Value = i64

fn current(&self) -> i64

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl ValueTree for proptest::num::i128::BinarySearch

type Value = i128

fn current(&self) -> i128

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl ValueTree for proptest::num::isize::BinarySearch

type Value = isize

fn current(&self) -> isize

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl ValueTree for proptest::num::u8::BinarySearch

type Value = u8

fn current(&self) -> u8

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl ValueTree for proptest::num::u16::BinarySearch

type Value = u16

fn current(&self) -> u16

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl ValueTree for proptest::num::u32::BinarySearch

type Value = u32

fn current(&self) -> u32

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl ValueTree for proptest::num::u64::BinarySearch

type Value = u64

fn current(&self) -> u64

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl ValueTree for proptest::num::u128::BinarySearch

type Value = u128

fn current(&self) -> u128

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl ValueTree for proptest::num::usize::BinarySearch

type Value = usize

fn current(&self) -> usize

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl ValueTree for IndexValueTree

type Value = Index

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl ValueTree for SelectorValueTree

type Value = Selector

fn current(&self) -> Selector

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<A: Strategy, B: Strategy<Value = A::Value>> ValueTree for TupleUnionValueTree<(LazyValueTree<A>, Option<LazyValueTree<B>>)>

type Value = A::Value

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<A: Strategy, B: Strategy<Value = A::Value>, C: Strategy<Value = A::Value>> ValueTree for TupleUnionValueTree<(LazyValueTree<A>, Option<LazyValueTree<B>>, Option<LazyValueTree<C>>)>

type Value = A::Value

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<A: Strategy, B: Strategy<Value = A::Value>, C: Strategy<Value = A::Value>, D: Strategy<Value = A::Value>> ValueTree for TupleUnionValueTree<(LazyValueTree<A>, Option<LazyValueTree<B>>, Option<LazyValueTree<C>>, Option<LazyValueTree<D>>)>

type Value = A::Value

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<A: Strategy, B: Strategy<Value = A::Value>, C: Strategy<Value = A::Value>, D: Strategy<Value = A::Value>, E: Strategy<Value = A::Value>> ValueTree for TupleUnionValueTree<(LazyValueTree<A>, Option<LazyValueTree<B>>, Option<LazyValueTree<C>>, Option<LazyValueTree<D>>, Option<LazyValueTree<E>>)>

type Value = A::Value

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<A: Strategy, B: Strategy<Value = A::Value>, C: Strategy<Value = A::Value>, D: Strategy<Value = A::Value>, E: Strategy<Value = A::Value>, F: Strategy<Value = A::Value>> ValueTree for TupleUnionValueTree<(LazyValueTree<A>, Option<LazyValueTree<B>>, Option<LazyValueTree<C>>, Option<LazyValueTree<D>>, Option<LazyValueTree<E>>, Option<LazyValueTree<F>>)>

type Value = A::Value

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<A: Strategy, B: Strategy<Value = A::Value>, C: Strategy<Value = A::Value>, D: Strategy<Value = A::Value>, E: Strategy<Value = A::Value>, F: Strategy<Value = A::Value>, G: Strategy<Value = A::Value>> ValueTree for TupleUnionValueTree<(LazyValueTree<A>, Option<LazyValueTree<B>>, Option<LazyValueTree<C>>, Option<LazyValueTree<D>>, Option<LazyValueTree<E>>, Option<LazyValueTree<F>>, Option<LazyValueTree<G>>)>

type Value = A::Value

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<A: Strategy, B: Strategy<Value = A::Value>, C: Strategy<Value = A::Value>, D: Strategy<Value = A::Value>, E: Strategy<Value = A::Value>, F: Strategy<Value = A::Value>, G: Strategy<Value = A::Value>, H: Strategy<Value = A::Value>> ValueTree for TupleUnionValueTree<(LazyValueTree<A>, Option<LazyValueTree<B>>, Option<LazyValueTree<C>>, Option<LazyValueTree<D>>, Option<LazyValueTree<E>>, Option<LazyValueTree<F>>, Option<LazyValueTree<G>>, Option<LazyValueTree<H>>)>

type Value = A::Value

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<A: Strategy, B: Strategy<Value = A::Value>, C: Strategy<Value = A::Value>, D: Strategy<Value = A::Value>, E: Strategy<Value = A::Value>, F: Strategy<Value = A::Value>, G: Strategy<Value = A::Value>, H: Strategy<Value = A::Value>, I: Strategy<Value = A::Value>> ValueTree for TupleUnionValueTree<(LazyValueTree<A>, Option<LazyValueTree<B>>, Option<LazyValueTree<C>>, Option<LazyValueTree<D>>, Option<LazyValueTree<E>>, Option<LazyValueTree<F>>, Option<LazyValueTree<G>>, Option<LazyValueTree<H>>, Option<LazyValueTree<I>>)>

type Value = A::Value

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<A: Strategy, B: Strategy<Value = A::Value>, C: Strategy<Value = A::Value>, D: Strategy<Value = A::Value>, E: Strategy<Value = A::Value>, F: Strategy<Value = A::Value>, G: Strategy<Value = A::Value>, H: Strategy<Value = A::Value>, I: Strategy<Value = A::Value>, J: Strategy<Value = A::Value>> ValueTree for TupleUnionValueTree<(LazyValueTree<A>, Option<LazyValueTree<B>>, Option<LazyValueTree<C>>, Option<LazyValueTree<D>>, Option<LazyValueTree<E>>, Option<LazyValueTree<F>>, Option<LazyValueTree<G>>, Option<LazyValueTree<H>>, Option<LazyValueTree<I>>, Option<LazyValueTree<J>>)>

type Value = A::Value

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<A: ValueTree> ValueTree for TupleValueTree<(A,)>

type Value = (A::Value,)

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<A: ValueTree, B: ValueTree> ValueTree for TupleValueTree<(A, B)>

type Value = (A::Value, B::Value)

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<A: ValueTree, B: ValueTree, C: ValueTree> ValueTree for TupleValueTree<(A, B, C)>

type Value = (A::Value, B::Value, C::Value)

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

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

type Value = (A::Value, B::Value, C::Value, D::Value)

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

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

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value)

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

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

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value)

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

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

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value)

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<A: ValueTree, B: ValueTree, C: ValueTree, D: ValueTree, E: ValueTree, F: ValueTree, G: ValueTree, H: ValueTree> ValueTree for TupleValueTree<(A, B, C, D, E, F, G, H)>

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value, H::Value)

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<A: ValueTree, B: ValueTree, C: ValueTree, D: ValueTree, E: ValueTree, F: ValueTree, G: ValueTree, H: ValueTree, I: ValueTree> ValueTree for TupleValueTree<(A, B, C, D, E, F, G, H, I)>

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value, H::Value, I::Value)

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<A: ValueTree, B: ValueTree, C: ValueTree, D: ValueTree, E: ValueTree, F: ValueTree, G: ValueTree, H: ValueTree, I: ValueTree, J: ValueTree> ValueTree for TupleValueTree<(A, B, C, D, E, F, G, H, I, J)>

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value, H::Value, I::Value, J::Value)

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<A: ValueTree, B: ValueTree, C: ValueTree, D: ValueTree, E: ValueTree, F: ValueTree, G: ValueTree, H: ValueTree, I: ValueTree, J: ValueTree, K: ValueTree> ValueTree for TupleValueTree<(A, B, C, D, E, F, G, H, I, J, K)>

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value, H::Value, I::Value, J::Value, K::Value)

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<A: ValueTree, B: ValueTree, C: ValueTree, D: ValueTree, E: ValueTree, F: ValueTree, G: ValueTree, H: ValueTree, I: ValueTree, J: ValueTree, K: ValueTree, L: ValueTree> ValueTree for TupleValueTree<(A, B, C, D, E, F, G, H, I, J, K, L)>

type Value = (A::Value, B::Value, C::Value, D::Value, E::Value, F::Value, G::Value, H::Value, I::Value, J::Value, K::Value, L::Value)

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<K, V> ValueTree for BTreeMapValueTree<K, V> where
    K: ValueTree,
    V: ValueTree,
    K::Value: Ord, 

type Value = BTreeMap<K::Value, V::Value>

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<S: ValueTree> ValueTree for FlattenValueTree<S> where
    S::Value: Strategy, 

type Value = <S::Value as Strategy>::Value

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<S: ValueTree, F: FilterFn<S::Value>> ValueTree for proptest::strategy::statics::Filter<S, F>

type Value = S::Value

fn current(&self) -> S::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<S: ValueTree, F: MapFn<S::Value>> ValueTree for proptest::strategy::statics::Map<S, F>

type Value = F::Output

fn current(&self) -> F::Output

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<S: ValueTree, F: Fn(&S::Value) -> bool> ValueTree for proptest::strategy::Filter<S, F>

type Value = S::Value

fn current(&self) -> S::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<S: ValueTree, O: Debug> ValueTree for MapInto<S, O> where
    S::Value: Into<O>, 

type Value = O

fn current(&self) -> O

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<S: ValueTree, O: Debug, F: Fn(S::Value) -> O> ValueTree for proptest::strategy::Map<S, F>

type Value = O

fn current(&self) -> O

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<S: ValueTree, O: Debug, F: Fn(S::Value, TestRng) -> O> ValueTree for PerturbValueTree<S, F>

type Value = O

fn current(&self) -> O

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T> ValueTree for BTreeSetValueTree<T> where
    T: ValueTree,
    T::Value: Ord, 

type Value = BTreeSet<T::Value>

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T> ValueTree for BinaryHeapValueTree<T> where
    T: ValueTree,
    T::Value: Ord, 

type Value = BinaryHeap<T::Value>

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T> ValueTree for LinkedListValueTree<T> where
    T: ValueTree, 

type Value = LinkedList<T::Value>

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T> ValueTree for VecDequeValueTree<T> where
    T: ValueTree, 

type Value = VecDeque<T::Value>

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T> ValueTree for OptionValueTree<T> where
    T: Strategy, 

type Value = Option<T::Value>

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T> ValueTree for SelectValueTree<T> where
    T: Clone + Debug + 'static, 

type Value = T

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T, E> ValueTree for MaybeErrValueTree<T, E> where
    T: Strategy,
    E: Strategy, 

type Value = Result<T::Value, E::Value>

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T, E> ValueTree for MaybeOkValueTree<T, E> where
    T: Strategy,
    E: Strategy, 

type Value = Result<T::Value, E::Value>

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: BitSetLike> ValueTree for BitSetValueTree<T>

type Value = T

fn current(&self) -> T

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: Strategy> ValueTree for UnionValueTree<T>

type Value = T::Value

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 1]>

type Value = [T::Value; 1]

fn current(&self) -> [T::Value; 1]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 2]>

type Value = [T::Value; 2]

fn current(&self) -> [T::Value; 2]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 3]>

type Value = [T::Value; 3]

fn current(&self) -> [T::Value; 3]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 4]>

type Value = [T::Value; 4]

fn current(&self) -> [T::Value; 4]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 5]>

type Value = [T::Value; 5]

fn current(&self) -> [T::Value; 5]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 6]>

type Value = [T::Value; 6]

fn current(&self) -> [T::Value; 6]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 7]>

type Value = [T::Value; 7]

fn current(&self) -> [T::Value; 7]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 8]>

type Value = [T::Value; 8]

fn current(&self) -> [T::Value; 8]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 9]>

type Value = [T::Value; 9]

fn current(&self) -> [T::Value; 9]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 10]>

type Value = [T::Value; 10]

fn current(&self) -> [T::Value; 10]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 11]>

type Value = [T::Value; 11]

fn current(&self) -> [T::Value; 11]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 12]>

type Value = [T::Value; 12]

fn current(&self) -> [T::Value; 12]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 13]>

type Value = [T::Value; 13]

fn current(&self) -> [T::Value; 13]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 14]>

type Value = [T::Value; 14]

fn current(&self) -> [T::Value; 14]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 15]>

type Value = [T::Value; 15]

fn current(&self) -> [T::Value; 15]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 16]>

type Value = [T::Value; 16]

fn current(&self) -> [T::Value; 16]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 17]>

type Value = [T::Value; 17]

fn current(&self) -> [T::Value; 17]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 18]>

type Value = [T::Value; 18]

fn current(&self) -> [T::Value; 18]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 19]>

type Value = [T::Value; 19]

fn current(&self) -> [T::Value; 19]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 20]>

type Value = [T::Value; 20]

fn current(&self) -> [T::Value; 20]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 21]>

type Value = [T::Value; 21]

fn current(&self) -> [T::Value; 21]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 22]>

type Value = [T::Value; 22]

fn current(&self) -> [T::Value; 22]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 23]>

type Value = [T::Value; 23]

fn current(&self) -> [T::Value; 23]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 24]>

type Value = [T::Value; 24]

fn current(&self) -> [T::Value; 24]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 25]>

type Value = [T::Value; 25]

fn current(&self) -> [T::Value; 25]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 26]>

type Value = [T::Value; 26]

fn current(&self) -> [T::Value; 26]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 27]>

type Value = [T::Value; 27]

fn current(&self) -> [T::Value; 27]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 28]>

type Value = [T::Value; 28]

fn current(&self) -> [T::Value; 28]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 29]>

type Value = [T::Value; 29]

fn current(&self) -> [T::Value; 29]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 30]>

type Value = [T::Value; 30]

fn current(&self) -> [T::Value; 30]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 31]>

type Value = [T::Value; 31]

fn current(&self) -> [T::Value; 31]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for ArrayValueTree<[T; 32]>

type Value = [T::Value; 32]

fn current(&self) -> [T::Value; 32]

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for VecValueTree<T>

type Value = Vec<T::Value>

fn current(&self) -> Vec<T::Value>

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for Fuse<T>

type Value = T::Value

fn current(&self) -> T::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: ValueTree> ValueTree for NoShrink<T>

type Value = T::Value

fn current(&self) -> T::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: Clone + Debug> ValueTree for Just<T>

type Value = T

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

fn current(&self) -> T

impl<T: Debug + Clone + 'static> ValueTree for SubsequenceValueTree<T>

type Value = Vec<T>

fn current(&self) -> Self::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<T: Debug> ValueTree for fn() -> T

type Value = T

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

fn current(&self) -> Self::Value

impl<T: Debug, F: Fn() -> T> ValueTree for LazyJust<T, F>

type Value = T

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

fn current(&self) -> Self::Value

impl<V: ValueTree> ValueTree for ShuffleValueTree<V> where
    V::Value: Shuffleable, 

type Value = V::Value

fn current(&self) -> V::Value

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

impl<V: ValueTree, F: Fn(V::Value) -> Option<O>, O: Debug> ValueTree for FilterMapValueTree<V, F, O>

type Value = O

fn current(&self) -> O

fn simplify(&mut self) -> bool

fn complicate(&mut self) -> bool

Loading content...