Struct proptest::array::UniformArrayStrategy

pub struct UniformArrayStrategy<S, T> { /* fields omitted */ }

A Strategy which generates fixed-size arrays containing values drawn from an inner strategy.

T must be an array type of length 1 to 32 whose values are produced by strategy S. Instances of this type are normally created by the various uniformXX functions in this module.

This is mainly useful when the inner strategy is not Copy, precluding expressing the strategy as [myStrategy; 32], for example.

Example

#[macro_use] extern crate proptest;
use proptest::prelude::*;

proptest! {
  #[test]
  fn test_something(a in prop::array::uniform32(1u32..)) {
    let unexpected = [0u32;32];
    // `a` is also a [u32;32], so we can compare them directly
    assert_ne!(unexpected, a);
  }
}

Methods

impl<S, T> UniformArrayStrategy<S, T>

pub fn new(strategy: S) -> Self

Directly create a UniformArrayStrategy.

This is only intended for advanced use, since the only way to specify the array size is with the turbofish operator and explicitly naming the type of the values in the array and the strategy itself.

Prefer the uniformXX functions at module-level unless something precludes their use.

Trait Implementations

impl<S: Clone, T: Clone> Clone for UniformArrayStrategy<S, T>

fn clone(&self) -> UniformArrayStrategy<S, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Copy, T: Copy> Copy for UniformArrayStrategy<S, T>

impl<S: Debug, T: Debug> Debug for UniformArrayStrategy<S, T>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 1]>

type Value = ArrayValueTree<[S::Value; 1]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 2]>

type Value = ArrayValueTree<[S::Value; 2]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 3]>

type Value = ArrayValueTree<[S::Value; 3]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 4]>

type Value = ArrayValueTree<[S::Value; 4]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 5]>

type Value = ArrayValueTree<[S::Value; 5]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 6]>

type Value = ArrayValueTree<[S::Value; 6]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 7]>

type Value = ArrayValueTree<[S::Value; 7]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 8]>

type Value = ArrayValueTree<[S::Value; 8]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 9]>

type Value = ArrayValueTree<[S::Value; 9]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 10]>

type Value = ArrayValueTree<[S::Value; 10]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 11]>

type Value = ArrayValueTree<[S::Value; 11]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 12]>

type Value = ArrayValueTree<[S::Value; 12]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 13]>

type Value = ArrayValueTree<[S::Value; 13]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 14]>

type Value = ArrayValueTree<[S::Value; 14]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 15]>

type Value = ArrayValueTree<[S::Value; 15]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 16]>

type Value = ArrayValueTree<[S::Value; 16]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 17]>

type Value = ArrayValueTree<[S::Value; 17]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 18]>

type Value = ArrayValueTree<[S::Value; 18]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 19]>

type Value = ArrayValueTree<[S::Value; 19]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 20]>

type Value = ArrayValueTree<[S::Value; 20]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 21]>

type Value = ArrayValueTree<[S::Value; 21]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 22]>

type Value = ArrayValueTree<[S::Value; 22]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 23]>

type Value = ArrayValueTree<[S::Value; 23]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 24]>

type Value = ArrayValueTree<[S::Value; 24]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 25]>

type Value = ArrayValueTree<[S::Value; 25]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 26]>

type Value = ArrayValueTree<[S::Value; 26]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 27]>

type Value = ArrayValueTree<[S::Value; 27]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 28]>

type Value = ArrayValueTree<[S::Value; 28]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 29]>

type Value = ArrayValueTree<[S::Value; 29]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 30]>

type Value = ArrayValueTree<[S::Value; 30]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 31]>

type Value = ArrayValueTree<[S::Value; 31]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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<S: Strategy> Strategy for UniformArrayStrategy<S, [ValueFor<S>; 32]>

type Value = ArrayValueTree<[S::Value; 32]>

The value tree generated by this Strategy.

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

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(ValueFor<Self>) -> 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,
    ValueFor<Self>: Into<O>, 

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

fn prop_perturb<O: Debug, F: Fn(ValueFor<Self>, XorShiftRng) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(ValueFor<Self>) -> 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(&ValueFor<Self>) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

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, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<ValueFor<Self>, F> where
    Self: Sized + 'static,
    F: Fn(BoxedStrategy<ValueFor<Self>>) -> R,
    R: Strategy + 'static,
    R::Value: ValueTree<Value = ValueFor<Self>>, 

Generate a recursive structure with self items as leaves.

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

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<ValueFor<Self>> 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<ValueFor<Self>> 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.