[−][src]Trait un_algebra::tests::config::prop::strategy::Strategy

#[must_use = "strategies do nothing unless used"]
pub trait Strategy: Debug where
    <Self::Tree as ValueTree>::Value == Self::Value, {
type Tree: ValueTree;
type Value: Debug;
    fn new_tree(&self, runner: &mut TestRunner) -> Result<Self::Tree, Reason>;

    fn prop_map<O, F>(self, fun: F) -> Map<Self, F>
    where
        F: Fn(Self::Value) -> O,
        O: Debug,
    { ... }
    fn prop_map_into<O>(self) -> MapInto<Self, O>
    where
        O: Debug,
        Self::Value: Into<O>,
    { ... }
    fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F>
    where
        F: Fn(Self::Value, TestRng) -> O,
        O: Debug,
    { ... }
    fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>>
    where
        F: Fn(Self::Value) -> S,
        S: Strategy,
    { ... }
    fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>>
    where
        F: Fn(Self::Value) -> S,
        S: Strategy,
    { ... }
    fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F>
    where
        F: Fn(Self::Value) -> S,
        S: Strategy,
    { ... }
    fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F>
    where
        F: Fn(&Self::Value) -> bool,
        R: Into<Reason>,
    { ... }
    fn prop_filter_map<F, O, impl Into>(
        self, 
        whence: impl Into, 
        fun: F
    ) -> FilterMap<Self, F>
    where
        F: Fn(Self::Value) -> Option<O>,
        O: Debug,
        impl Into: Into<Reason>,
    { ... }
    fn prop_union(self, other: Self) -> Union<Self> { ... }
    fn prop_recursive<R, F>(
        self, 
        depth: u32, 
        desired_size: u32, 
        expected_branch_size: u32, 
        recurse: F
    ) -> Recursive<Self::Value, F>
    where
        F: Fn(BoxedStrategy<Self::Value>) -> R,
        R: 'static + Strategy<Value = Self::Value>,
        Self: 'static,
    { ... }
    fn prop_shuffle(self) -> Shuffle<Self>
    where
        Self::Value: Shuffleable,
    { ... }
    fn boxed(self) -> BoxedStrategy<Self::Value>
    where
        Self: 'static,
    { ... }
    fn sboxed(self) -> SBoxedStrategy<Self::Value>
    where
        Self: Send + Sync + 'static,
    { ... }
    fn no_shrink(self) -> NoShrink<Self> { ... }
}

A strategy for producing arbitrary values of a given type.

fmt::Debug is a hard requirement for all strategies currently due to prop_flat_map(). This constraint will be removed when specialisation becomes stable.

Associated Types

`type Tree: ValueTree`

The value tree generated by this Strategy.

`type Value: Debug`

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

This corresponds to the same type as the associated type Value in Self::Tree. It is provided here to simplify usage particularly in conjunction with -> impl Strategy<Value = MyType>.

Loading content...

Required methods

`fn new_tree(&self, runner: &mut TestRunner) -> Result<Self::Tree, Reason>`

Generate a new value tree from the given runner.

This may fail if there are constraints on the generated value and the generator is unable to produce anything that satisfies them. Any failure is wrapped in TestError::Abort.

This method is generally expected to be deterministic. That is, given a TestRunner with its RNG in a particular state, this should produce an identical ValueTree every time. Non-deterministic strategies do not cause problems during normal operation, but they do break failure persistence since it is implemented by simply saving the seed used to generate the test case.

Loading content...

Provided methods

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

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

There is no need (or possibility, for that matter) to define how the output is to be shrunken. Shrinking continues to take place in terms of the source value.

fun should be a deterministic function. That is, for a given input value, it should produce an equivalent output value on every call. Proptest assumes that it can call the function as many times as needed to generate as many identical values as needed. For this reason, F is Fn rather than FnMut.

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

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

You should always prefer this operation instead of prop_map when you can as it is both clearer and also currently more efficient.

There is no need (or possibility, for that matter) to define how the output is to be shrunken. Shrinking continues to take place in terms of the source value.

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

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

This is exactly like prop_map() except for the addition of the second argument to the function. This allows introducing chaotic variations to generated values that are not easily expressed otherwise while allowing shrinking to proceed reasonably.

During shrinking, fun is always called with an identical random number generator, so if it is a pure function it will always perform the same perturbation.

Example

// The prelude also gets us the `Rng` trait.
use proptest::prelude::*;

proptest! {
  #[test]
  fn test_something(a in (0i32..10).prop_perturb(
      // Perturb the integer `a` (range 0..10) to a pair of that
      // integer and another that's ± 10 of it.
      // Note that this particular case would be better implemented as
      // `(0i32..10, -10i32..10).prop_map(|(a, b)| (a, a + b))`
      // but is shown here for simplicity.
      |centre, rng| (centre, centre + rng.gen_range(-10, 10))))
  {
      // Test stuff
  }
}

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

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

fun is used to transform the values produced by this strategy into other strategies. Values are then chosen from the derived strategies. Shrinking proceeds by shrinking individual values as well as shrinking the input used to generate the internal strategies.

Shrinking

In the case of test failure, shrinking will not only shrink the output from the combinator itself, but also the input, i.e., the strategy used to generate the output itself. Doing this requires searching the new derived strategy for a new failing input. The combinator will generate up to Config::cases values for this search.

As a result, nested prop_flat_map/Flatten combinators risk exponential run time on this search for new failing values. To ensure that test failures occur within a reasonable amount of time, all of these combinators share a single "flat map regen" counter, and will stop generating new values if it exceeds Config::max_flat_map_regens.

Example

Generate two integers, where the second is always less than the first, without using filtering:

use proptest::prelude::*;

proptest! {
  #[test]
  fn test_two(
    // Pick integers in the 1..65536 range, and derive a strategy
    // which emits a tuple of that integer and another one which is
    // some value less than it.
    (a, b) in (1..65536).prop_flat_map(|a| (Just(a), 0..a))
  ) {
    prop_assert!(b < a);
  }
}

Choosing the right flat-map

Strategy has three "flat-map" combinators. They look very similar at first, and can be used to produce superficially identical test results. For example, the following three expressions all produce inputs which are 2-tuples (a,b) where the b component is less than a.

use proptest::prelude::*;

let flat_map = (1..10).prop_flat_map(|a| (Just(a), 0..a));
let ind_flat_map = (1..10).prop_ind_flat_map(|a| (Just(a), 0..a));
let ind_flat_map2 = (1..10).prop_ind_flat_map2(|a| 0..a);

The three do differ however in terms of how they shrink.

For flat_map, both a and b will shrink, and the invariant that b < a is maintained. This is a "dependent" or "higher-order" strategy in that it remembers that the strategy for choosing b is dependent on the value chosen for a.

For ind_flat_map, the invariant b < a is maintained, but only because a does not shrink. This is due to the fact that the dependency between the strategies is not tracked; a is simply seen as a constant.

Finally, for ind_flat_map2, the invariant b < a is not maintained, because a can shrink independently of b, again because the dependency between the two variables is not tracked, but in this case the derivation of a is still exposed to the shrinking system.

The use-cases for the independent flat-map variants is pretty narrow. For the majority of cases where invariants need to be maintained and you want all components to shrink, prop_flat_map is the way to go. prop_ind_flat_map makes the most sense when the input to the map function is not exposed in the output and shrinking across strategies is not expected to be useful. prop_ind_flat_map2 is useful for using related values as starting points while not constraining them to that relation.

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

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

This is very similar to prop_flat_map(), but shrinking will not attempt to shrink the input that produces the derived strategies. This is appropriate for when the derived strategies already fully shrink in the desired way.

In most cases, you want prop_flat_map().

See prop_flat_map() for a more detailed explanation on how the three flat-map combinators differ.

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

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.

See prop_flat_map() for a more detailed explanation on how the three flat-map combinators differ differ.

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

Returns a strategy which only produces values accepted by fun.

This results in a very naïve form of rejection sampling and should only be used if (a) relatively few values will actually be rejected; (b) it isn't easy to express what you want by using another strategy and/or map().

There are a lot of downsides to this form of filtering. It slows testing down, since values must be generated but then discarded. Proptest only allows a limited number of rejects this way (across the entire TestRunner). Rejection can interfere with shrinking; particularly, complex filters may largely or entirely prevent shrinking from substantially altering the original value.

Local rejection sampling is still preferable to rejecting the entire input to a test (via TestCaseError::Reject), however, and the default number of local rejections allowed is much higher than the number of whole-input rejections.

whence is used to record where and why the rejection occurred.

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

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

Using this method is preferable to using .prop_map(..).prop_filter(..).

This results in a very naïve form of rejection sampling and should only be used if (a) relatively few values will actually be rejected; (b) it isn't easy to express what you want by using another strategy and/or map().

There are a lot of downsides to this form of filtering. It slows testing down, since values must be generated but then discarded. Proptest only allows a limited number of rejects this way (across the entire TestRunner). Rejection can interfere with shrinking; particularly, complex filters may largely or entirely prevent shrinking from substantially altering the original value.

Local rejection sampling is still preferable to rejecting the entire input to a test (via TestCaseError::Reject), however, and the default number of local rejections allowed is much higher than the number of whole-input rejections.

whence is used to record where and why the rejection occurred.

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

Returns a strategy which picks uniformly from self and other.

When shrinking, if a value from other was originally chosen but that value can be shrunken no further, it switches to a value from self and starts shrinking that.

Be aware that chaining prop_union calls will result in a very right-skewed distribution. If this is not what you want, you can call the .or() method on the Union to add more values to the same union, or directly call Union::new().

Both self and other must be of the same type. To combine heterogeneous strategies, call the boxed() method on both self and other to erase the type differences before calling prop_union().

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

Generate a recursive structure with self items as leaves.

recurse is applied to various strategies that produce the same type as self with nesting depth n to create a strategy that produces the same type with nesting depth n+1. Generated structures will have a depth between 0 and depth and will usually have up to desired_size total elements, though they may have more. expected_branch_size gives the expected maximum size for any collection which may contain recursive elements and is used to control branch probability to achieve the desired size. Passing a too small value can result in trees vastly larger than desired.

Note that depth only counts branches; i.e., depth = 0 is a single leaf, and depth = 1 is a leaf or a branch containing only leaves.

In practise, generated values usually have a lower depth than depth (but depth is a hard limit) and almost always under expected_branch_size (though it is not a hard limit) since the underlying code underestimates probabilities.

Shrinking shrinks both the inner values and attempts switching from recursive to non-recursive cases.

Example

use std::collections::HashMap;

use proptest::prelude::*;

/// Define our own JSON AST type
#[derive(Debug, Clone)]
enum JsonNode {
  Null,
  Bool(bool),
  Number(f64),
  String(String),
  Array(Vec<JsonNode>),
  Map(HashMap<String, JsonNode>),
}

// Define a strategy for generating leaf nodes of the AST
let json_leaf = prop_oneof![
  Just(JsonNode::Null),
  prop::bool::ANY.prop_map(JsonNode::Bool),
  prop::num::f64::ANY.prop_map(JsonNode::Number),
  ".*".prop_map(JsonNode::String),
];

// Now define a strategy for a whole tree
let json_tree = json_leaf.prop_recursive(
  4, // No more than 4 branch levels deep
  64, // Target around 64 total elements
  16, // Each collection is up to 16 elements long
  |element| prop_oneof![
    // NB `element` is an `Arc` and we'll need to reference it twice,
    // so we clone it the first time.
    prop::collection::vec(element.clone(), 0..16)
      .prop_map(JsonNode::Array),
    prop::collection::hash_map(".*", element, 0..16)
      .prop_map(JsonNode::Map)
  ]);

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

Shuffle the contents of the values produced by this strategy.

That is, this modifies a strategy producing a Vec, slice, etc, to shuffle the contents of that Vec/slice/etc.

Initially, the value is fully shuffled. During shrinking, the input value will initially be unchanged while the result will gradually be restored to its original order. Once de-shuffling either completes or is cancelled by calls to complicate() pinning it to a particular permutation, the inner value will be simplified.

Example

use proptest::prelude::*;

static VALUES: &'static [u32] = &[0, 1, 2, 3, 4];

fn is_permutation(orig: &[u32], mut actual: Vec<u32>) -> bool {
  actual.sort();
  orig == &actual[..]
}

proptest! {
  #[test]
  fn test_is_permutation(
      ref perm in Just(VALUES.to_owned()).prop_shuffle()
  ) {
      assert!(is_permutation(VALUES, perm.clone()));
  }
}

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

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

See also sboxed() if this Strategy is Send and Sync and you want to preserve that information.

Strategies of this type afford cheap shallow cloning via reference counting by using an Arc internally.

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

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

Unlike boxed(), this conversion retains the Send and Sync traits on the output.

Strategies of this type afford cheap shallow cloning via reference counting by using an Arc internally.

`fn no_shrink(self) -> NoShrink<Self>`

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

Suppressing shrinking is useful when testing things like linear approximation functions. Ordinarily, proptest will tend to shrink the input to the function until the result is just barely outside the acceptable range whereas the original input may have produced a result far outside of it. Since this makes it harder to see what the actual problem is, making the input NoShrink allows learning about inputs that produce more incorrect results.

Loading content...

Implementations on Foreign Types

`impl<S> Strategy for [S; 20] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 20]>`

`type Value = [<S as Strategy>::Value; 20]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 20] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 22] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 22]>`

`type Value = [<S as Strategy>::Value; 22]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 22] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 32] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 32]>`

`type Value = [<S as Strategy>::Value; 32]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 32] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 2] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 2]>`

`type Value = [<S as Strategy>::Value; 2]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 2] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 4] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 4]>`

`type Value = [<S as Strategy>::Value; 4]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 4] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 24] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 24]>`

`type Value = [<S as Strategy>::Value; 24]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 24] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for Arc<S> where S: Strategy + ?Sized,` [src]

`type Tree = <S as Strategy>::Tree`

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

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Arc<S> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for str`[src]

`type Tree = RegexGeneratorValueTree<String>`

`type Value = String`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<str as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 26] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 26]>`

`type Value = [<S as Strategy>::Value; 26]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 26] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<A, B, C, D, E, F, G> Strategy for (A, B, C, D, E, F, G) where A: Strategy, B: Strategy, C: Strategy, D: Strategy, E: Strategy, F: Strategy, G: Strategy,` [src]

`type Tree = TupleValueTree<(<A as Strategy>::Tree, ::Tree, <C as Strategy>::Tree, <D as Strategy>::Tree, <E as Strategy>::Tree, <F as Strategy>::Tree, <G as Strategy>::Tree)>`

`type Value = (<A as Strategy>::Value, ::Value, <C as Strategy>::Value, <D as Strategy>::Value, <E as Strategy>::Value, <F as Strategy>::Value, <G as Strategy>::Value)`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<(A, B, C, D, E, F, G) as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<A, B, C, D, E, F, G, H, I, J> Strategy for (A, B, C, D, E, F, G, H, I, J) where A: Strategy, B: Strategy, C: Strategy, D: Strategy, E: Strategy, F: Strategy, G: Strategy, H: Strategy, I: Strategy, J: Strategy,` [src]

`type Tree = TupleValueTree<(<A as Strategy>::Tree, ::Tree, <C as Strategy>::Tree, <D as Strategy>::Tree, <E as Strategy>::Tree, <F as Strategy>::Tree, <G as Strategy>::Tree, <H as Strategy>::Tree, ::Tree, <J as Strategy>::Tree)>`

`type Value = (<A as Strategy>::Value, ::Value, <C as Strategy>::Value, <D as Strategy>::Value, <E as Strategy>::Value, <F as Strategy>::Value, <G as Strategy>::Value, <H as Strategy>::Value, ::Value, <J as Strategy>::Value)`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<(A, B, C, D, E, F, G, H, I, J) as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<A, B> Strategy for (A, B) where A: Strategy, B: Strategy,` [src]

`type Tree = TupleValueTree<(<A as Strategy>::Tree, ::Tree)>`

`type Value = (<A as Strategy>::Value, ::Value)`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<(A, B) as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 21] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 21]>`

`type Value = [<S as Strategy>::Value; 21]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 21] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 3] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 3]>`

`type Value = [<S as Strategy>::Value; 3]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 3] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<A, B, C, D, E, F> Strategy for (A, B, C, D, E, F) where A: Strategy, B: Strategy, C: Strategy, D: Strategy, E: Strategy, F: Strategy,` [src]

`type Tree = TupleValueTree<(<A as Strategy>::Tree, ::Tree, <C as Strategy>::Tree, <D as Strategy>::Tree, <E as Strategy>::Tree, <F as Strategy>::Tree)>`

`type Value = (<A as Strategy>::Value, ::Value, <C as Strategy>::Value, <D as Strategy>::Value, <E as Strategy>::Value, <F as Strategy>::Value)`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<(A, B, C, D, E, F) as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 6] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 6]>`

`type Value = [<S as Strategy>::Value; 6]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 6] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 18] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 18]>`

`type Value = [<S as Strategy>::Value; 18]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 18] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 10] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 10]>`

`type Value = [<S as Strategy>::Value; 10]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 10] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 1] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 1]>`

`type Value = [<S as Strategy>::Value; 1]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 1] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 27] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 27]>`

`type Value = [<S as Strategy>::Value; 27]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 27] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<'a, S> Strategy for &'a mut S where S: Strategy + ?Sized,` [src]

`type Tree = <S as Strategy>::Tree`

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

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<&'a mut S as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for Vec<T> where T: Strategy,` [src]

`type Tree = VecValueTree<<T as Strategy>::Tree>`

`type Value = Vec<<T as Strategy>::Value>`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Vec<T> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 8] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 8]>`

`type Value = [<S as Strategy>::Value; 8]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 8] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 9] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 9]>`

`type Value = [<S as Strategy>::Value; 9]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 9] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<A> Strategy for (A,) where A: Strategy,` [src]

`type Tree = TupleValueTree<(<A as Strategy>::Tree,)>`

`type Value = (<A as Strategy>::Value,)`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<(A,) as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 13] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 13]>`

`type Value = [<S as Strategy>::Value; 13]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 13] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 16] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 16]>`

`type Value = [<S as Strategy>::Value; 16]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 16] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<A, B, C, D, E> Strategy for (A, B, C, D, E) where A: Strategy, B: Strategy, C: Strategy, D: Strategy, E: Strategy,` [src]

`type Tree = TupleValueTree<(<A as Strategy>::Tree, ::Tree, <C as Strategy>::Tree, <D as Strategy>::Tree, <E as Strategy>::Tree)>`

`type Value = (<A as Strategy>::Value, ::Value, <C as Strategy>::Value, <D as Strategy>::Value, <E as Strategy>::Value)`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<(A, B, C, D, E) as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 14] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 14]>`

`type Value = [<S as Strategy>::Value; 14]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 14] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 17] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 17]>`

`type Value = [<S as Strategy>::Value; 17]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 17] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 30] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 30]>`

`type Value = [<S as Strategy>::Value; 30]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 30] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<A, B, C, D> Strategy for (A, B, C, D) where A: Strategy, B: Strategy, C: Strategy, D: Strategy,` [src]

`type Tree = TupleValueTree<(<A as Strategy>::Tree, ::Tree, <C as Strategy>::Tree, <D as Strategy>::Tree)>`

`type Value = (<A as Strategy>::Value, ::Value, <C as Strategy>::Value, <D as Strategy>::Value)`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<(A, B, C, D) as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 25] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 25]>`

`type Value = [<S as Strategy>::Value; 25]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 25] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<A, B, C, D, E, F, G, H, I> Strategy for (A, B, C, D, E, F, G, H, I) where A: Strategy, B: Strategy, C: Strategy, D: Strategy, E: Strategy, F: Strategy, G: Strategy, H: Strategy, I: Strategy,` [src]

`type Tree = TupleValueTree<(<A as Strategy>::Tree, ::Tree, <C as Strategy>::Tree, <D as Strategy>::Tree, <E as Strategy>::Tree, <F as Strategy>::Tree, <G as Strategy>::Tree, <H as Strategy>::Tree, ::Tree)>`

`type Value = (<A as Strategy>::Value, ::Value, <C as Strategy>::Value, <D as Strategy>::Value, <E as Strategy>::Value, <F as Strategy>::Value, <G as Strategy>::Value, <H as Strategy>::Value, ::Value)`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<(A, B, C, D, E, F, G, H, I) as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<A, B, C, D, E, F, G, H> Strategy for (A, B, C, D, E, F, G, H) where A: Strategy, B: Strategy, C: Strategy, D: Strategy, E: Strategy, F: Strategy, G: Strategy, H: Strategy,` [src]

`type Tree = TupleValueTree<(<A as Strategy>::Tree, ::Tree, <C as Strategy>::Tree, <D as Strategy>::Tree, <E as Strategy>::Tree, <F as Strategy>::Tree, <G as Strategy>::Tree, <H as Strategy>::Tree)>`

`type Value = (<A as Strategy>::Value, ::Value, <C as Strategy>::Value, <D as Strategy>::Value, <E as Strategy>::Value, <F as Strategy>::Value, <G as Strategy>::Value, <H as Strategy>::Value)`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<(A, B, C, D, E, F, G, H) as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 19] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 19]>`

`type Value = [<S as Strategy>::Value; 19]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 19] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 29] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 29]>`

`type Value = [<S as Strategy>::Value; 29]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 29] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<'a, S> Strategy for &'a S where S: Strategy + ?Sized,` [src]

`type Tree = <S as Strategy>::Tree`

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

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<&'a S as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for Rc<S> where S: Strategy + ?Sized,` [src]

`type Tree = <S as Strategy>::Tree`

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

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Rc<S> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for Box<S> where S: Strategy + ?Sized,` [src]

`type Tree = <S as Strategy>::Tree`

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

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Box<S> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 11] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 11]>`

`type Value = [<S as Strategy>::Value; 11]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 11] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 5] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 5]>`

`type Value = [<S as Strategy>::Value; 5]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 5] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 15] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 15]>`

`type Value = [<S as Strategy>::Value; 15]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 15] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for fn() -> T where T: Debug,` [src]

`type Tree = fn() -> T`

`type Value = T`

`fn new_tree( &self, &mut TestRunner ) -> Result<<fn() -> T as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 12] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 12]>`

`type Value = [<S as Strategy>::Value; 12]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 12] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<A, B, C> Strategy for (A, B, C) where A: Strategy, B: Strategy, C: Strategy,` [src]

`type Tree = TupleValueTree<(<A as Strategy>::Tree, ::Tree, <C as Strategy>::Tree)>`

`type Value = (<A as Strategy>::Value, ::Value, <C as Strategy>::Value)`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<(A, B, C) as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 28] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 28]>`

`type Value = [<S as Strategy>::Value; 28]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 28] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 23] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 23]>`

`type Value = [<S as Strategy>::Value; 23]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 23] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 7] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 7]>`

`type Value = [<S as Strategy>::Value; 7]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 7] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 31] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 31]>`

`type Value = [<S as Strategy>::Value; 31]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 31] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

Loading content...

Implementors

`impl Strategy for un_algebra::tests::config::prop::bool::Any`[src]

`type Tree = BoolValueTree`

`type Value = bool`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Any as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for Weighted`[src]

`type Tree = BoolValueTree`

`type Value = bool`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Weighted as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for un_algebra::tests::config::prop::num::f32::Any`[src]

`type Tree = BinarySearch`

`type Value = f32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Any as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for un_algebra::tests::config::prop::num::f64::Any`[src]

`type Tree = BinarySearch`

`type Value = f64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Any as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for un_algebra::tests::config::prop::num::i128::Any`[src]

`type Tree = BinarySearch`

`type Value = i128`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Any as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for un_algebra::tests::config::prop::num::i16::Any`[src]

`type Tree = BinarySearch`

`type Value = i16`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Any as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for un_algebra::tests::config::prop::num::i32::Any`[src]

`type Tree = BinarySearch`

`type Value = i32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Any as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for un_algebra::tests::config::prop::num::i64::Any`[src]

`type Tree = BinarySearch`

`type Value = i64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Any as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for un_algebra::tests::config::prop::num::i8::Any`[src]

`type Tree = BinarySearch`

`type Value = i8`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Any as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for un_algebra::tests::config::prop::num::isize::Any`[src]

`type Tree = BinarySearch`

`type Value = isize`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Any as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for un_algebra::tests::config::prop::num::u128::Any`[src]

`type Tree = BinarySearch`

`type Value = u128`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Any as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for un_algebra::tests::config::prop::num::u16::Any`[src]

`type Tree = BinarySearch`

`type Value = u16`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Any as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for un_algebra::tests::config::prop::num::u32::Any`[src]

`type Tree = BinarySearch`

`type Value = u32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Any as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for un_algebra::tests::config::prop::num::u64::Any`[src]

`type Tree = BinarySearch`

`type Value = u64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Any as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for un_algebra::tests::config::prop::num::u8::Any`[src]

`type Tree = BinarySearch`

`type Value = u8`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Any as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for un_algebra::tests::config::prop::num::usize::Any`[src]

`type Tree = BinarySearch`

`type Value = usize`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Any as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for IndexStrategy`[src]

`type Tree = IndexValueTree`

`type Value = Index`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<IndexStrategy as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for SelectorStrategy`[src]

`type Tree = SelectorValueTree`

`type Value = Selector`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<SelectorStrategy as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for Range<f32>`[src]

`type Tree = BinarySearch`

`type Value = f32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Range<f32> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for Range<f64>`[src]

`type Tree = BinarySearch`

`type Value = f64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Range<f64> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for Range<i128>`[src]

`type Tree = BinarySearch`

`type Value = i128`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Range<i128> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for Range<i16>`[src]

`type Tree = BinarySearch`

`type Value = i16`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Range<i16> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for Range<i32>`[src]

`type Tree = BinarySearch`

`type Value = i32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Range<i32> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for Range<i64>`[src]

`type Tree = BinarySearch`

`type Value = i64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Range<i64> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for Range<i8>`[src]

`type Tree = BinarySearch`

`type Value = i8`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Range<i8> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for Range<isize>`[src]

`type Tree = BinarySearch`

`type Value = isize`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Range<isize> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for Range<u128>`[src]

`type Tree = BinarySearch`

`type Value = u128`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Range<u128> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for Range<u16>`[src]

`type Tree = BinarySearch`

`type Value = u16`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Range<u16> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for Range<u32>`[src]

`type Tree = BinarySearch`

`type Value = u32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Range<u32> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for Range<u64>`[src]

`type Tree = BinarySearch`

`type Value = u64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Range<u64> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for Range<u8>`[src]

`type Tree = BinarySearch`

`type Value = u8`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Range<u8> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for Range<usize>`[src]

`type Tree = BinarySearch`

`type Value = usize`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Range<usize> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeFrom<f32>`[src]

`type Tree = BinarySearch`

`type Value = f32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeFrom<f32> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeFrom<f64>`[src]

`type Tree = BinarySearch`

`type Value = f64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeFrom<f64> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeFrom<i128>`[src]

`type Tree = BinarySearch`

`type Value = i128`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeFrom<i128> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeFrom<i16>`[src]

`type Tree = BinarySearch`

`type Value = i16`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeFrom<i16> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeFrom<i32>`[src]

`type Tree = BinarySearch`

`type Value = i32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeFrom<i32> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeFrom<i64>`[src]

`type Tree = BinarySearch`

`type Value = i64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeFrom<i64> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeFrom<i8>`[src]

`type Tree = BinarySearch`

`type Value = i8`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeFrom<i8> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeFrom<isize>`[src]

`type Tree = BinarySearch`

`type Value = isize`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeFrom<isize> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeFrom<u128>`[src]

`type Tree = BinarySearch`

`type Value = u128`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeFrom<u128> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeFrom<u16>`[src]

`type Tree = BinarySearch`

`type Value = u16`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeFrom<u16> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeFrom<u32>`[src]

`type Tree = BinarySearch`

`type Value = u32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeFrom<u32> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeFrom<u64>`[src]

`type Tree = BinarySearch`

`type Value = u64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeFrom<u64> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeFrom<u8>`[src]

`type Tree = BinarySearch`

`type Value = u8`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeFrom<u8> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeFrom<usize>`[src]

`type Tree = BinarySearch`

`type Value = usize`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeFrom<usize> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeInclusive<f32>`[src]

`type Tree = BinarySearch`

`type Value = f32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeInclusive<f32> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeInclusive<f64>`[src]

`type Tree = BinarySearch`

`type Value = f64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeInclusive<f64> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeInclusive<i128>`[src]

`type Tree = BinarySearch`

`type Value = i128`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeInclusive<i128> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeInclusive<i16>`[src]

`type Tree = BinarySearch`

`type Value = i16`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeInclusive<i16> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeInclusive<i32>`[src]

`type Tree = BinarySearch`

`type Value = i32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeInclusive<i32> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeInclusive<i64>`[src]

`type Tree = BinarySearch`

`type Value = i64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeInclusive<i64> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeInclusive<i8>`[src]

`type Tree = BinarySearch`

`type Value = i8`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeInclusive<i8> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeInclusive<isize>`[src]

`type Tree = BinarySearch`

`type Value = isize`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeInclusive<isize> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeInclusive<u128>`[src]

`type Tree = BinarySearch`

`type Value = u128`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeInclusive<u128> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeInclusive<u16>`[src]

`type Tree = BinarySearch`

`type Value = u16`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeInclusive<u16> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeInclusive<u32>`[src]

`type Tree = BinarySearch`

`type Value = u32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeInclusive<u32> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeInclusive<u64>`[src]

`type Tree = BinarySearch`

`type Value = u64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeInclusive<u64> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeInclusive<u8>`[src]

`type Tree = BinarySearch`

`type Value = u8`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeInclusive<u8> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeInclusive<usize>`[src]

`type Tree = BinarySearch`

`type Value = usize`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeInclusive<usize> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeTo<f32>`[src]

`type Tree = BinarySearch`

`type Value = f32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeTo<f32> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeTo<f64>`[src]

`type Tree = BinarySearch`

`type Value = f64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeTo<f64> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeTo<i128>`[src]

`type Tree = BinarySearch`

`type Value = i128`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeTo<i128> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeTo<i16>`[src]

`type Tree = BinarySearch`

`type Value = i16`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeTo<i16> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeTo<i32>`[src]

`type Tree = BinarySearch`

`type Value = i32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeTo<i32> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeTo<i64>`[src]

`type Tree = BinarySearch`

`type Value = i64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeTo<i64> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeTo<i8>`[src]

`type Tree = BinarySearch`

`type Value = i8`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeTo<i8> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeTo<isize>`[src]

`type Tree = BinarySearch`

`type Value = isize`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeTo<isize> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeTo<u128>`[src]

`type Tree = BinarySearch`

`type Value = u128`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeTo<u128> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeTo<u16>`[src]

`type Tree = BinarySearch`

`type Value = u16`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeTo<u16> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeTo<u32>`[src]

`type Tree = BinarySearch`

`type Value = u32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeTo<u32> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeTo<u64>`[src]

`type Tree = BinarySearch`

`type Value = u64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeTo<u64> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeTo<u8>`[src]

`type Tree = BinarySearch`

`type Value = u8`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeTo<u8> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeTo<usize>`[src]

`type Tree = BinarySearch`

`type Value = usize`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeTo<usize> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeToInclusive<f32>`[src]

`type Tree = BinarySearch`

`type Value = f32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeToInclusive<f32> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeToInclusive<f64>`[src]

`type Tree = BinarySearch`

`type Value = f64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeToInclusive<f64> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeToInclusive<i128>`[src]

`type Tree = BinarySearch`

`type Value = i128`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeToInclusive<i128> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeToInclusive<i16>`[src]

`type Tree = BinarySearch`

`type Value = i16`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeToInclusive<i16> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

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

`fn prop_union(self, other: Self) -> Union<Self>`[src]

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

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeToInclusive<i32>`[src]

`type Tree = BinarySearch`

`type Value = i32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeToInclusive<i32> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

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

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

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

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

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

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeToInclusive<i64>`[src]

`type Tree = BinarySearch`

`type Value = i64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeToInclusive<i64> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeToInclusive<i8>`[src]

`type Tree = BinarySearch`

`type Value = i8`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeToInclusive<i8> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeToInclusive<isize>`[src]

`type Tree = BinarySearch`

`type Value = isize`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeToInclusive<isize> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeToInclusive<u128>`[src]

`type Tree = BinarySearch`

`type Value = u128`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeToInclusive<u128> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeToInclusive<u16>`[src]

`type Tree = BinarySearch`

`type Value = u16`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeToInclusive<u16> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeToInclusive<u32>`[src]

`type Tree = BinarySearch`

`type Value = u32`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeToInclusive<u32> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeToInclusive<u64>`[src]

`type Tree = BinarySearch`

`type Value = u64`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeToInclusive<u64> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeToInclusive<u8>`[src]

`type Tree = BinarySearch`

`type Value = u8`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeToInclusive<u8> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl Strategy for RangeToInclusive<usize>`[src]

`type Tree = BinarySearch`

`type Value = usize`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RangeToInclusive<usize> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<'a> Strategy for CharStrategy<'a>`[src]

`type Tree = CharValueTree`

`type Value = char`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<CharStrategy<'a> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<A, B> Strategy for TupleUnion<((u32, A), (u32, B))> where A: Strategy, B: Strategy<Value = <A as Strategy>::Value>,` [src]

`type Tree = TupleUnionValueTree<(<A as Strategy>::Tree, Option<::Tree>)>`

`type Value = <A as Strategy>::Value`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<TupleUnion<((u32, A), (u32, B))> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<A, B, C> Strategy for TupleUnion<((u32, A), (u32, B), (u32, C))> where A: Strategy, B: Strategy<Value = <A as Strategy>::Value>, C: Strategy<Value = <A as Strategy>::Value>,` [src]

`type Tree = TupleUnionValueTree<(<A as Strategy>::Tree, Option<::Tree>, Option<<C as Strategy>::Tree>)>`

`type Value = <A as Strategy>::Value`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<TupleUnion<((u32, A), (u32, B), (u32, C))> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<A, B, C, D> Strategy for TupleUnion<((u32, A), (u32, B), (u32, C), (u32, D))> where A: Strategy, B: Strategy<Value = <A as Strategy>::Value>, C: Strategy<Value = <A as Strategy>::Value>, D: Strategy<Value = <A as Strategy>::Value>,` [src]

`type Tree = TupleUnionValueTree<(<A as Strategy>::Tree, Option<::Tree>, Option<<C as Strategy>::Tree>, Option<<D as Strategy>::Tree>)>`

`type Value = <A as Strategy>::Value`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<TupleUnion<((u32, A), (u32, B), (u32, C), (u32, D))> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<A, B, C, D, E> Strategy for TupleUnion<((u32, A), (u32, B), (u32, C), (u32, D), (u32, E))> where A: Strategy, B: Strategy<Value = <A as Strategy>::Value>, C: Strategy<Value = <A as Strategy>::Value>, D: Strategy<Value = <A as Strategy>::Value>, E: Strategy<Value = <A as Strategy>::Value>,` [src]

`type Tree = TupleUnionValueTree<(<A as Strategy>::Tree, Option<::Tree>, Option<<C as Strategy>::Tree>, Option<<D as Strategy>::Tree>, Option<<E as Strategy>::Tree>)>`

`type Value = <A as Strategy>::Value`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<TupleUnion<((u32, A), (u32, B), (u32, C), (u32, D), (u32, E))> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<A, B, C, D, E, F> Strategy for TupleUnion<((u32, A), (u32, B), (u32, C), (u32, D), (u32, E), (u32, F))> where A: Strategy, B: Strategy<Value = <A as Strategy>::Value>, C: Strategy<Value = <A as Strategy>::Value>, D: Strategy<Value = <A as Strategy>::Value>, E: Strategy<Value = <A as Strategy>::Value>, F: Strategy<Value = <A as Strategy>::Value>,` [src]

`type Tree = TupleUnionValueTree<(<A as Strategy>::Tree, Option<::Tree>, Option<<C as Strategy>::Tree>, Option<<D as Strategy>::Tree>, Option<<E as Strategy>::Tree>, Option<<F as Strategy>::Tree>)>`

`type Value = <A as Strategy>::Value`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<TupleUnion<((u32, A), (u32, B), (u32, C), (u32, D), (u32, E), (u32, F))> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<A, B, C, D, E, F, G> Strategy for TupleUnion<((u32, A), (u32, B), (u32, C), (u32, D), (u32, E), (u32, F), (u32, G))> where A: Strategy, B: Strategy<Value = <A as Strategy>::Value>, C: Strategy<Value = <A as Strategy>::Value>, D: Strategy<Value = <A as Strategy>::Value>, E: Strategy<Value = <A as Strategy>::Value>, F: Strategy<Value = <A as Strategy>::Value>, G: Strategy<Value = <A as Strategy>::Value>,` [src]

`type Tree = TupleUnionValueTree<(<A as Strategy>::Tree, Option<::Tree>, Option<<C as Strategy>::Tree>, Option<<D as Strategy>::Tree>, Option<<E as Strategy>::Tree>, Option<<F as Strategy>::Tree>, Option<<G as Strategy>::Tree>)>`

`type Value = <A as Strategy>::Value`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<TupleUnion<((u32, A), (u32, B), (u32, C), (u32, D), (u32, E), (u32, F), (u32, G))> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

impl<A, B, C, D, E, F, G, H> Strategy for TupleUnion<((u32, A), (u32, B), (u32, C), (u32, D), (u32, E), (u32, F), (u32, G), (u32, H))> where A: Strategy, B: Strategy<Value = <A as Strategy>::Value>, C: Strategy<Value = <A as Strategy>::Value>, D: Strategy<Value = <A as Strategy>::Value>, E: Strategy<Value = <A as Strategy>::Value>, F: Strategy<Value = <A as Strategy>::Value>, G: Strategy<Value = <A as Strategy>::Value>, H: Strategy<Value = <A as Strategy>::Value>, [src]

`type Tree = TupleUnionValueTree<(<A as Strategy>::Tree, Option<::Tree>, Option<<C as Strategy>::Tree>, Option<<D as Strategy>::Tree>, Option<<E as Strategy>::Tree>, Option<<F as Strategy>::Tree>, Option<<G as Strategy>::Tree>, Option<<H as Strategy>::Tree>)>`

`type Value = <A as Strategy>::Value`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<TupleUnion<((u32, A), (u32, B), (u32, C), (u32, D), (u32, E), (u32, F), (u32, G), (u32, H))> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

impl<A, B, C, D, E, F, G, H, I> Strategy for TupleUnion<((u32, A), (u32, B), (u32, C), (u32, D), (u32, E), (u32, F), (u32, G), (u32, H), (u32, I))> where A: Strategy, B: Strategy<Value = <A as Strategy>::Value>, C: Strategy<Value = <A as Strategy>::Value>, D: Strategy<Value = <A as Strategy>::Value>, E: Strategy<Value = <A as Strategy>::Value>, F: Strategy<Value = <A as Strategy>::Value>, G: Strategy<Value = <A as Strategy>::Value>, H: Strategy<Value = <A as Strategy>::Value>, I: Strategy<Value = <A as Strategy>::Value>, [src]

`type Tree = TupleUnionValueTree<(<A as Strategy>::Tree, Option<::Tree>, Option<<C as Strategy>::Tree>, Option<<D as Strategy>::Tree>, Option<<E as Strategy>::Tree>, Option<<F as Strategy>::Tree>, Option<<G as Strategy>::Tree>, Option<<H as Strategy>::Tree>, Option<::Tree>)>`

`type Value = <A as Strategy>::Value`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<TupleUnion<((u32, A), (u32, B), (u32, C), (u32, D), (u32, E), (u32, F), (u32, G), (u32, H), (u32, I))> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

impl<A, B, C, D, E, F, G, H, I, J> Strategy for TupleUnion<((u32, A), (u32, B), (u32, C), (u32, D), (u32, E), (u32, F), (u32, G), (u32, H), (u32, I), (u32, J))> where A: Strategy, B: Strategy<Value = <A as Strategy>::Value>, C: Strategy<Value = <A as Strategy>::Value>, D: Strategy<Value = <A as Strategy>::Value>, E: Strategy<Value = <A as Strategy>::Value>, F: Strategy<Value = <A as Strategy>::Value>, G: Strategy<Value = <A as Strategy>::Value>, H: Strategy<Value = <A as Strategy>::Value>, I: Strategy<Value = <A as Strategy>::Value>, J: Strategy<Value = <A as Strategy>::Value>, [src]

`type Tree = TupleUnionValueTree<(<A as Strategy>::Tree, Option<::Tree>, Option<<C as Strategy>::Tree>, Option<<D as Strategy>::Tree>, Option<<E as Strategy>::Tree>, Option<<F as Strategy>::Tree>, Option<<G as Strategy>::Tree>, Option<<H as Strategy>::Tree>, Option<::Tree>, Option<<J as Strategy>::Tree>)>`

`type Value = <A as Strategy>::Value`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<TupleUnion<((u32, A), (u32, B), (u32, C), (u32, D), (u32, E), (u32, F), (u32, G), (u32, H), (u32, I), (u32, J))> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<K, V> Strategy for BTreeMapStrategy<K, V> where K: Strategy, V: Strategy, <K as Strategy>::Value: Ord,` [src]

`type Tree = BTreeMapValueTree<<K as Strategy>::Tree, <V as Strategy>::Tree>`

`type Value = BTreeMap<<K as Strategy>::Value, <V as Strategy>::Value>`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<BTreeMapStrategy<K, V> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<K, V> Strategy for HashMapStrategy<K, V> where K: Strategy, V: Strategy, <K as Strategy>::Value: Hash, <K as Strategy>::Value: Eq,` [src]

`type Tree = HashMapValueTree<<K as Strategy>::Tree, <V as Strategy>::Tree>`

`type Value = HashMap<<K as Strategy>::Value, <V as Strategy>::Value, RandomState>`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<HashMapStrategy<K, V> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 1]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 1]>`

`type Value = [<S as Strategy>::Value; 1]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 1]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 2]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 2]>`

`type Value = [<S as Strategy>::Value; 2]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 2]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 3]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 3]>`

`type Value = [<S as Strategy>::Value; 3]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 3]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 4]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 4]>`

`type Value = [<S as Strategy>::Value; 4]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 4]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 5]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 5]>`

`type Value = [<S as Strategy>::Value; 5]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 5]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 6]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 6]>`

`type Value = [<S as Strategy>::Value; 6]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 6]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 7]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 7]>`

`type Value = [<S as Strategy>::Value; 7]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 7]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 8]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 8]>`

`type Value = [<S as Strategy>::Value; 8]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 8]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 9]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 9]>`

`type Value = [<S as Strategy>::Value; 9]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 9]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 10]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 10]>`

`type Value = [<S as Strategy>::Value; 10]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 10]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 11]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 11]>`

`type Value = [<S as Strategy>::Value; 11]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 11]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 12]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 12]>`

`type Value = [<S as Strategy>::Value; 12]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 12]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 13]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 13]>`

`type Value = [<S as Strategy>::Value; 13]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 13]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 14]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 14]>`

`type Value = [<S as Strategy>::Value; 14]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 14]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 15]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 15]>`

`type Value = [<S as Strategy>::Value; 15]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 15]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 16]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 16]>`

`type Value = [<S as Strategy>::Value; 16]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 16]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 17]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 17]>`

`type Value = [<S as Strategy>::Value; 17]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 17]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 18]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 18]>`

`type Value = [<S as Strategy>::Value; 18]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 18]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 19]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 19]>`

`type Value = [<S as Strategy>::Value; 19]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 19]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 20]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 20]>`

`type Value = [<S as Strategy>::Value; 20]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 20]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 21]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 21]>`

`type Value = [<S as Strategy>::Value; 21]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 21]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 22]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 22]>`

`type Value = [<S as Strategy>::Value; 22]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 22]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 23]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 23]>`

`type Value = [<S as Strategy>::Value; 23]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 23]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 24]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 24]>`

`type Value = [<S as Strategy>::Value; 24]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 24]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 25]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 25]>`

`type Value = [<S as Strategy>::Value; 25]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 25]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 26]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 26]>`

`type Value = [<S as Strategy>::Value; 26]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 26]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 27]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 27]>`

`type Value = [<S as Strategy>::Value; 27]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 27]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 28]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 28]>`

`type Value = [<S as Strategy>::Value; 28]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 28]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 29]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 29]>`

`type Value = [<S as Strategy>::Value; 29]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 29]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 30]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 30]>`

`type Value = [<S as Strategy>::Value; 30]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 30]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 31]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 31]>`

`type Value = [<S as Strategy>::Value; 31]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 31]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for UniformArrayStrategy<S, [<S as Strategy>::Value; 32]> where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 32]>`

`type Value = [<S as Strategy>::Value; 32]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<UniformArrayStrategy<S, [<S as Strategy>::Value; 32]> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for Flatten<S> where S: Strategy, <S as Strategy>::Value: Strategy,` [src]

`type Tree = FlattenValueTree<<S as Strategy>::Tree>`

`type Value = <<S as Strategy>::Value as Strategy>::Value`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Flatten<S> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for IndFlatten<S> where S: Strategy, <S as Strategy>::Value: Strategy,` [src]

`type Tree = <<S as Strategy>::Value as Strategy>::Tree`

`type Value = <<S as Strategy>::Value as Strategy>::Value`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<IndFlatten<S> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for Shuffle<S> where S: Strategy, <S as Strategy>::Value: Shuffleable,` [src]

`type Tree = ShuffleValueTree<<S as Strategy>::Tree>`

`type Value = <S as Strategy>::Value`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Shuffle<S> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S, F> Strategy for un_algebra::tests::config::prop::strategy::statics::Filter<S, F> where F: FilterFn<<S as Strategy>::Value> + Clone, S: Strategy,` [src]

`type Tree = Filter<<S as Strategy>::Tree, F>`

`type Value = <S as Strategy>::Value`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Filter<S, F> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S, F> Strategy for un_algebra::tests::config::prop::strategy::statics::Map<S, F> where F: MapFn<<S as Strategy>::Value> + Clone, S: Strategy,` [src]

`type Tree = Map<<S as Strategy>::Tree, F>`

`type Value = <F as MapFn<<S as Strategy>::Value>>::Output`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Map<S, F> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S, F> Strategy for un_algebra::tests::config::prop::strategy::Filter<S, F> where F: Fn(&<S as Strategy>::Value) -> bool, S: Strategy,` [src]

`type Tree = Filter<<S as Strategy>::Tree, F>`

`type Value = <S as Strategy>::Value`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Filter<S, F> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S, F, O> Strategy for FilterMap<S, F> where F: Fn(<S as Strategy>::Value) -> Option<O>, O: Debug, S: Strategy,` [src]

`type Tree = FilterMapValueTree<<S as Strategy>::Tree, F, O>`

`type Value = O`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<FilterMap<S, F> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S, O> Strategy for MapInto<S, O> where O: Debug, S: Strategy, <S as Strategy>::Value: Into<O>,` [src]

`type Tree = MapInto<<S as Strategy>::Tree, O>`

`type Value = O`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<MapInto<S, O> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S, O, F> Strategy for un_algebra::tests::config::prop::strategy::Map<S, F> where F: Fn(<S as Strategy>::Value) -> O, O: Debug, S: Strategy,` [src]

`type Tree = Map<<S as Strategy>::Tree, F>`

`type Value = O`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Map<S, F> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S, O, F> Strategy for Perturb<S, F> where F: Fn(<S as Strategy>::Value, TestRng) -> O, O: Debug, S: Strategy,` [src]

`type Tree = PerturbValueTree<<S as Strategy>::Tree, F>`

`type Value = O`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Perturb<S, F> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S, R, F> Strategy for IndFlattenMap<S, F> where F: Fn(<S as Strategy>::Value) -> R, R: Strategy, S: Strategy,` [src]

`type Tree = TupleValueTree<(<S as Strategy>::Tree, <R as Strategy>::Tree)>`

`type Value = (<S as Strategy>::Value, <R as Strategy>::Value)`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<IndFlattenMap<S, F> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for BitSetStrategy<T> where T: BitSetLike,` [src]

`type Tree = BitSetValueTree<T>`

`type Value = T`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<BitSetStrategy<T> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for SampledBitSetStrategy<T> where T: BitSetLike,` [src]

`type Tree = BitSetValueTree<T>`

`type Value = T`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<SampledBitSetStrategy<T> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for BTreeSetStrategy<T> where T: Strategy, <T as Strategy>::Value: Ord,` [src]

`type Tree = BTreeSetValueTree<<T as Strategy>::Tree>`

`type Value = BTreeSet<<T as Strategy>::Value>`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<BTreeSetStrategy<T> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for BinaryHeapStrategy<T> where T: Strategy, <T as Strategy>::Value: Ord,` [src]

`type Tree = BinaryHeapValueTree<<T as Strategy>::Tree>`

`type Value = BinaryHeap<<T as Strategy>::Value>`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<BinaryHeapStrategy<T> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for HashSetStrategy<T> where T: Strategy, <T as Strategy>::Value: Hash, <T as Strategy>::Value: Eq,` [src]

`type Tree = HashSetValueTree<<T as Strategy>::Tree>`

`type Value = HashSet<<T as Strategy>::Value, RandomState>`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<HashSetStrategy<T> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for LinkedListStrategy<T> where T: Strategy,` [src]

`type Tree = LinkedListValueTree<<T as Strategy>::Tree>`

`type Value = LinkedList<<T as Strategy>::Value>`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<LinkedListStrategy<T> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for VecDequeStrategy<T> where T: Strategy,` [src]

`type Tree = VecDequeValueTree<<T as Strategy>::Tree>`

`type Value = VecDeque<<T as Strategy>::Value>`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<VecDequeStrategy<T> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for VecStrategy<T> where T: Strategy,` [src]

`type Tree = VecValueTree<<T as Strategy>::Tree>`

`type Value = Vec<<T as Strategy>::Value>`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<VecStrategy<T> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for OptionStrategy<T> where T: Strategy,` [src]

`type Tree = OptionValueTree<<T as Strategy>::Tree>`

`type Value = Option<<T as Strategy>::Value>`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<OptionStrategy<T> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for Select<T> where T: Clone + Debug + 'static,` [src]

`type Tree = SelectValueTree<T>`

`type Value = T`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Select<T> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for Subsequence<T> where T: 'static + Clone + Debug,` [src]

`type Tree = SubsequenceValueTree<T>`

`type Value = Vec<T>`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Subsequence<T> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for BoxedStrategy<T> where T: Debug,` [src]

`type Tree = Box<dyn ValueTree<Value = T> + 'static>`

`type Value = T`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<BoxedStrategy<T> as Strategy>::Tree, Reason>`[src]

`fn boxed(self) -> BoxedStrategy<<BoxedStrategy<T> as Strategy>::Value> where BoxedStrategy<T>: Sized, BoxedStrategy<T>: 'static,` [src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for Fuse<T> where T: Strategy,` [src]

`type Tree = Fuse<<T as Strategy>::Tree>`

`type Value = <T as Strategy>::Value`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Fuse<T> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for Just<T> where T: Clone + Debug,` [src]

`type Tree = Just<T>`

`type Value = T`

`fn new_tree( &self, &mut TestRunner ) -> Result<<Just<T> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for NoShrink<T> where T: Strategy,` [src]

`type Tree = NoShrink<<T as Strategy>::Tree>`

`type Value = <T as Strategy>::Value`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<NoShrink<T> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for SBoxedStrategy<T> where T: Debug,` [src]

`type Tree = Box<dyn ValueTree<Value = T> + 'static>`

`type Value = T`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<SBoxedStrategy<T> as Strategy>::Tree, Reason>`[src]

`fn sboxed(self) -> SBoxedStrategy<<SBoxedStrategy<T> as Strategy>::Value> where SBoxedStrategy<T>: Sized, SBoxedStrategy<T>: Send, SBoxedStrategy<T>: Sync, SBoxedStrategy<T>: 'static,` [src]

`fn boxed(self) -> BoxedStrategy<<SBoxedStrategy<T> as Strategy>::Value> where SBoxedStrategy<T>: Sized, SBoxedStrategy<T>: 'static,` [src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for Union<T> where T: Strategy,` [src]

`type Tree = UnionValueTree<<T as Strategy>::Tree>`

`type Value = <T as Strategy>::Value`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Union<T> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T> Strategy for RegexGeneratorStrategy<T> where T: Debug,` [src]

`type Tree = RegexGeneratorValueTree<T>`

`type Value = T`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<RegexGeneratorStrategy<T> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T, E> Strategy for MaybeErr<T, E> where E: Strategy, T: Strategy,` [src]

`type Tree = MaybeErrValueTree<<T as Strategy>::Tree, <E as Strategy>::Tree>`

`type Value = Result<<T as Strategy>::Value, <E as Strategy>::Value>`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<MaybeErr<T, E> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T, E> Strategy for MaybeOk<T, E> where E: Strategy, T: Strategy,` [src]

`type Tree = MaybeOkValueTree<<T as Strategy>::Tree, <E as Strategy>::Tree>`

`type Value = Result<<T as Strategy>::Value, <E as Strategy>::Value>`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<MaybeOk<T, E> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T, F> Strategy for LazyJust<T, F> where F: Fn() -> T + Clone, T: Debug,` [src]

`type Tree = LazyJust<T, F>`

`type Value = T`

`fn new_tree( &self, &mut TestRunner ) -> Result<<LazyJust<T, F> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<T, R, F> Strategy for Recursive<T, F> where F: Fn(BoxedStrategy<T>) -> R, R: 'static + Strategy<Value = T>, T: Debug + 'static,` [src]

`type Tree = Box<dyn ValueTree<Value = T> + 'static>`

`type Value = T`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Recursive<T, F> as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

Loading content...

[−][src]Trait un_algebra::tests::config::prop::strategy::Strategy

Associated Types

type Tree: ValueTree

type Value: Debug

Required methods

fn new_tree(&self, runner: &mut TestRunner) -> Result<Self::Tree, Reason>

Provided methods

fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,

fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,

Example

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,

Shrinking

Example

Choosing the right flat-map

fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,

fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,

fn prop_union(self, other: Self) -> Union<Self>

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,

Example

fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,

Example

fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,

fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,

fn no_shrink(self) -> NoShrink<Self>

Implementations on Foreign Types

impl<S> Strategy for [S; 20] where S: Strategy, [src]

type Tree = ArrayValueTree<[<S as Strategy>::Tree; 20]>

type Value = [<S as Strategy>::Value; 20]

fn new_tree( &self, runner: &mut TestRunner) -> Result<<[S; 20] as Strategy>::Tree, Reason>[src]

fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug, [src]

fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>, [src]

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug, [src]

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy, [src]

fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy, [src]

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy, [src]

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>, [src]

fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>, [src]

fn prop_union(self, other: Self) -> Union<Self>[src]

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static, [src]

fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable, [src]

fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static, [src]

fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static, [src]

fn no_shrink(self) -> NoShrink<Self>[src]

impl<S> Strategy for [S; 22] where S: Strategy, [src]

type Tree = ArrayValueTree<[<S as Strategy>::Tree; 22]>

type Value = [<S as Strategy>::Value; 22]

fn new_tree( &self, runner: &mut TestRunner) -> Result<<[S; 22] as Strategy>::Tree, Reason>[src]

fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug, [src]

fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>, [src]

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug, [src]

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy, [src]

fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy, [src]

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy, [src]

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>, [src]

fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>, [src]

fn prop_union(self, other: Self) -> Union<Self>[src]

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static, [src]

fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable, [src]

fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static, [src]

fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static, [src]

fn no_shrink(self) -> NoShrink<Self>[src]

impl<S> Strategy for [S; 32] where S: Strategy, [src]

type Tree = ArrayValueTree<[<S as Strategy>::Tree; 32]>

type Value = [<S as Strategy>::Value; 32]

fn new_tree( &self, runner: &mut TestRunner) -> Result<<[S; 32] as Strategy>::Tree, Reason>[src]

fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug, [src]

fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>, [src]

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug, [src]

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy, [src]

fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy, [src]

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy, [src]

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>, [src]

fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>, [src]

fn prop_union(self, other: Self) -> Union<Self>[src]

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static, [src]

fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable, [src]

fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static, [src]

`type Tree: ValueTree`

`type Value: Debug`

`fn new_tree(&self, runner: &mut TestRunner) -> Result<Self::Tree, Reason>`

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,`

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,`

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,`

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,`

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,`

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,`

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,`

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,`

`fn prop_union(self, other: Self) -> Union<Self>`

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,`

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,`

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,`

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,`

`fn no_shrink(self) -> NoShrink<Self>`

`impl<S> Strategy for [S; 20] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 20]>`

`type Value = [<S as Strategy>::Value; 20]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 20] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 22] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 22]>`

`type Value = [<S as Strategy>::Value; 22]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 22] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 32] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 32]>`

`type Value = [<S as Strategy>::Value; 32]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 32] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F> where F: Fn(&Self::Value) -> bool, R: Into<Reason>,` [src]

`fn prop_filter_map<F, O, impl Into>( self, whence: impl Into, fun: F ) -> FilterMap<Self, F> where F: Fn(Self::Value) -> Option<O>, O: Debug, impl Into: Into<Reason>,` [src]

`fn prop_union(self, other: Self) -> Union<Self>`[src]

`fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F ) -> Recursive<Self::Value, F> where F: Fn(BoxedStrategy<Self::Value>) -> R, R: 'static + Strategy<Value = Self::Value>, Self: 'static,` [src]

`fn prop_shuffle(self) -> Shuffle<Self> where Self::Value: Shuffleable,` [src]

`fn boxed(self) -> BoxedStrategy<Self::Value> where Self: 'static,` [src]

`fn sboxed(self) -> SBoxedStrategy<Self::Value> where Self: Send + Sync + 'static,` [src]

`fn no_shrink(self) -> NoShrink<Self>`[src]

`impl<S> Strategy for [S; 2] where S: Strategy,` [src]

`type Tree = ArrayValueTree<[<S as Strategy>::Tree; 2]>`

`type Value = [<S as Strategy>::Value; 2]`

`fn new_tree( &self, runner: &mut TestRunner ) -> Result<<[S; 2] as Strategy>::Tree, Reason>`[src]

`fn prop_map<O, F>(self, fun: F) -> Map<Self, F> where F: Fn(Self::Value) -> O, O: Debug,` [src]

`fn prop_map_into<O>(self) -> MapInto<Self, O> where O: Debug, Self::Value: Into<O>,` [src]

`fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F> where F: Fn(Self::Value, TestRng) -> O, O: Debug,` [src]

`fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]

`fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>> where F: Fn(Self::Value) -> S, S: Strategy,` [src]