Struct proptest::strategy::Fuse

pub struct Fuse<T> { /* private fields */ }

Adaptor for Strategy and ValueTree which guards simplify() and complicate() to avoid contract violations.

This can be used as an intermediate when the caller would otherwise need its own separate state tracking, or as a workaround for a broken ValueTree implementation.

This wrapper specifically has the following effects:

• Calling complicate() before simplify() was ever called does nothing and returns false.

• Calling simplify() after it has returned false and no calls to complicate() returned true does nothing and returns false.

• Calling complicate() after it has returned false and no calls to simplify() returned true does nothing and returns false.

There is also limited functionality to alter the internal state to assist in its usage as a state tracker.

Wrapping a Strategy in Fuse simply causes its ValueTree to also be wrapped in Fuse.

While this is similar to std::iter::Fuse, it is not exposed as a method on Strategy since the vast majority of proptest should never need this functionality; it mainly concerns implementors of strategies.

Implementations

impl<T> Fuse<T>

pub fn new(inner: T) -> Self

Wrap the given T in Fuse.

impl<T: ValueTree> Fuse<T>

pub fn may_simplify(&self) -> bool

Return whether a call to simplify() may be productive.

Formally, this is true if one of the following holds:

• simplify() has never been called.
• The most recent call to simplify() returned true.
• complicate() has been called more recently than simplify() and the last call returned true.

pub fn disallow_simplify(&mut self)

Disallow any further calls to simplify() until a call to complicate() returns true.

pub fn may_complicate(&self) -> bool

Return whether a call to complicate() may be productive.

Formally, this is true if one of the following holds:

• The most recent call to complicate() returned true.
• simplify() has been called more recently than complicate() and the last call returned true.

pub fn disallow_complicate(&mut self)

Disallow any further calls to complicate() until a call to simplify() returns true.

pub fn freeze(&mut self)

Prevent any further shrinking operations from occurring.

Trait Implementations

impl<T: Clone> Clone for Fuse<T>

fn clone(&self) -> Fuse<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Fuse<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Strategy> Strategy for Fuse<T>

type Tree = Fuse<<T as Strategy>::Tree>

The value tree generated by this Strategy.

type Value = <T as Strategy>::Value

The type of value used by functions under test generated by this Strategy.

fn new_tree(&self, runner: &mut TestRunner) -> NewTree<Self>

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(Self::Value) -> O>(self, fun: F) -> Map<Self, F> where
    Self: Sized, 

Returns a strategy which produces values transformed by the function fun.

fn prop_map_into<O: Debug>(self) -> MapInto<Self, O> where
    Self: Sized,
    Self::Value: Into<O>, 

Returns a strategy which produces values of type O by transforming Self with Into<O>.

fn prop_perturb<O: Debug, F: Fn(Self::Value, TestRng) -> O>(
    self,
    fun: F
) -> Perturb<Self, F> where
    Self: Sized, 

Returns a strategy which produces values transformed by the function fun, which is additionally given a random number generator.

fn prop_flat_map<S: Strategy, F: Fn(Self::Value) -> S>(
    self,
    fun: F
) -> Flatten<Map<Self, F>> where
    Self: Sized, 

Maps values produced by this strategy into new strategies and picks values from those strategies.

fn prop_ind_flat_map<S: Strategy, F: Fn(Self::Value) -> S>(
    self,
    fun: F
) -> IndFlatten<Map<Self, F>> where
    Self: Sized, 

Maps values produced by this strategy into new strategies and picks values from those strategies while considering the new strategies to be independent.

fn prop_ind_flat_map2<S: Strategy, F: Fn(Self::Value) -> S>(
    self,
    fun: F
) -> IndFlattenMap<Self, F> where
    Self: Sized, 

Similar to prop_ind_flat_map(), but produces 2-tuples with the input generated from self in slot 0 and the derived strategy in slot 1.

fn prop_filter<R: Into<Reason>, F: Fn(&Self::Value) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F: Fn(Self::Value) -> Option<O>, O: Debug>(
    self,
    whence: impl Into<Reason>,
    fun: F
) -> FilterMap<Self, F> where
    Self: Sized, 

Returns a strategy which only produces transformed values where fun returns Some(value) and rejects those where fun returns None.

fn prop_union(self, other: Self) -> Union<Self> where
    Self: Sized, 

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<Self::Value, F> where
    Self: Sized + 'static, 

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self> where
    Self: Sized,
    Self::Value: Shuffleable, 

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value> where
    Self: Sized + 'static, 

Erases the type of this Strategy so it can be passed around as a simple trait object.

fn sboxed(self) -> SBoxedStrategy<Self::Value> where
    Self: Sized + Send + Sync + 'static, 

Erases the type of this Strategy so it can be passed around as a simple trait object.

fn no_shrink(self) -> NoShrink<Self> where
    Self: Sized, 

Wraps this strategy to prevent values from being subject to shrinking.

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

type Value = <T as ValueTree>::Value

The type of the value produced by this ValueTree.

fn current(&self) -> T::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.

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.

impl<T: Copy> Copy for Fuse<T>