Struct un_algebra::tests::float::RangeTo

pub struct RangeTo<Idx> {
    pub end: Idx,
}

A range only bounded exclusively above (..end).

The RangeTo ..end contains all values with x < end. It cannot serve as an Iterator because it doesn't have a starting point.

Examples

The ..end syntax is a RangeTo:

assert_eq!((..5), std::ops::RangeTo { end: 5 });

It does not have an IntoIterator implementation, so you can't use it in a for loop directly. This won't compile:

// error[E0277]: the trait bound `std::ops::RangeTo<{integer}>:
// std::iter::Iterator` is not satisfied
for i in ..5 {
    // ...
}

When used as a slicing index, RangeTo produces a slice of all array elements before the index indicated by end.

let arr = [0, 1, 2, 3, 4];
assert_eq!(arr[ ..  ], [0,1,2,3,4]);
assert_eq!(arr[ .. 3], [0,1,2    ]);  // RangeTo
assert_eq!(arr[ ..=3], [0,1,2,3  ]);
assert_eq!(arr[1..  ], [  1,2,3,4]);
assert_eq!(arr[1.. 3], [  1,2    ]);
assert_eq!(arr[1..=3], [  1,2,3  ]);

Fields

end: Idx

The upper bound of the range (exclusive).

Methods

impl<Idx> RangeTo<Idx> where
    Idx: PartialOrd<Idx>, 

pub fn contains<U>(&self, item: &U) -> bool where
    Idx: PartialOrd<U>,
    U: PartialOrd<Idx> + ?Sized, 

Returns true if item is contained in the range.

Examples

use std::f32;

assert!( (..5).contains(&-1_000_000_000));
assert!( (..5).contains(&4));
assert!(!(..5).contains(&5));

assert!( (..1.0).contains(&0.5));
assert!(!(..1.0).contains(&f32::NAN));
assert!(!(..f32::NAN).contains(&0.5));

Trait Implementations

impl<'_, T> RangeBounds<T> for RangeTo<&'_ T>

fn start_bound(&self) -> Bound<&T>

Start index bound.

fn end_bound(&self) -> Bound<&T>

End index bound.

fn contains<U>(&self, item: &U) -> bool where
    T: PartialOrd<U>,
    U: PartialOrd<T> + ?Sized, 

Returns true if item is contained in the range.

impl<T> RangeBounds<T> for RangeTo<T>

fn start_bound(&self) -> Bound<&T>

Start index bound.

fn end_bound(&self) -> Bound<&T>

End index bound.

fn contains<U>(&self, item: &U) -> bool where
    T: PartialOrd<U>,
    U: PartialOrd<T> + ?Sized, 

Returns true if item is contained in the range.

impl<Idx> Hash for RangeTo<Idx> where
    Idx: Hash, 

fn hash<__HIdx>(&self, state: &mut __HIdx) where
    __HIdx: Hasher, 

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<Idx> Eq for RangeTo<Idx> where
    Idx: Eq, 

impl<Idx> Clone for RangeTo<Idx> where
    Idx: Clone, 

fn clone(&self) -> RangeTo<Idx>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Idx> Debug for RangeTo<Idx> where
    Idx: Debug, 

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

Formats the value using the given formatter.

impl SliceIndex<str> for RangeTo<usize>

Implements substring slicing with syntax &self[.. end] or &mut self[.. end].

Returns a slice of the given string from the byte range [0, end). Equivalent to &self[0 .. end] or &mut self[0 .. end].

This operation is O(1).

Prior to 1.20.0, these indexing operations were still supported by direct implementation of Index and IndexMut.

Panics

Panics if end does not point to the starting byte offset of a character (as defined by is_char_boundary), or if end > len.

type Output = str

The output type returned by methods.

fn get(
    self,
    slice: &str
) -> Option<&<RangeTo<usize> as SliceIndex<str>>::Output>

🔬 This is a nightly-only experimental API. (slice_index_methods)

Returns a shared reference to the output at this location, if in bounds.

fn get_mut(
    self,
    slice: &mut str
) -> Option<&mut <RangeTo<usize> as SliceIndex<str>>::Output>

🔬 This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable reference to the output at this location, if in bounds.

unsafe fn get_unchecked(
    self,
    slice: &str
) -> &<RangeTo<usize> as SliceIndex<str>>::Output

🔬 This is a nightly-only experimental API. (slice_index_methods)

Returns a shared reference to the output at this location, without performing any bounds checking.

unsafe fn get_unchecked_mut(
    self,
    slice: &mut str
) -> &mut <RangeTo<usize> as SliceIndex<str>>::Output

🔬 This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable reference to the output at this location, without performing any bounds checking.

fn index(self, slice: &str) -> &<RangeTo<usize> as SliceIndex<str>>::Output

🔬 This is a nightly-only experimental API. (slice_index_methods)

Returns a shared reference to the output at this location, panicking if out of bounds.

fn index_mut(
    self,
    slice: &mut str
) -> &mut <RangeTo<usize> as SliceIndex<str>>::Output

🔬 This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable reference to the output at this location, panicking if out of bounds.

impl<T> SliceIndex<[T]> for RangeTo<usize>

type Output = [T]

The output type returned by methods.

fn get(self, slice: &[T]) -> Option<&[T]>

🔬 This is a nightly-only experimental API. (slice_index_methods)

Returns a shared reference to the output at this location, if in bounds.

fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]>

🔬 This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable reference to the output at this location, if in bounds.

unsafe fn get_unchecked(self, slice: &[T]) -> &[T]

🔬 This is a nightly-only experimental API. (slice_index_methods)

Returns a shared reference to the output at this location, without performing any bounds checking.

unsafe fn get_unchecked_mut(self, slice: &mut [T]) -> &mut [T]

🔬 This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable reference to the output at this location, without performing any bounds checking.

fn index(self, slice: &[T]) -> &[T]

🔬 This is a nightly-only experimental API. (slice_index_methods)

Returns a shared reference to the output at this location, panicking if out of bounds.

fn index_mut(self, slice: &mut [T]) -> &mut [T]

🔬 This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable reference to the output at this location, panicking if out of bounds.

impl<Idx> Copy for RangeTo<Idx> where
    Idx: Copy, 

impl<Idx> PartialEq<RangeTo<Idx>> for RangeTo<Idx> where
    Idx: PartialEq<Idx>, 

fn eq(&self, other: &RangeTo<Idx>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &RangeTo<Idx>) -> bool

This method tests for !=.

impl IndexMut<RangeTo<usize>> for String

fn index_mut(&mut self, index: RangeTo<usize>) -> &mut str

Performs the mutable indexing (container[index]) operation.

impl Index<RangeTo<usize>> for String

type Output = str

The returned type after indexing.

fn index(&self, index: RangeTo<usize>) -> &str

Performs the indexing (container[index]) operation.

impl Strategy for RangeTo<u128>

type Tree = BinarySearch

The value tree generated by this Strategy.

type Value = u128

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

fn new_tree(
    &self,
    runner: &mut TestRunner
) -> Result<<RangeTo<u128> as Strategy>::Tree, Reason>

Generate a new value tree from the given runner.

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.

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>.

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.

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.

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.

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.

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.

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.

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

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<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.

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

Shuffle the contents of the values produced by this strategy.

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.

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.

fn no_shrink(self) -> NoShrink<Self>

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

impl Strategy for RangeTo<f64>

type Tree = BinarySearch

The value tree generated by this Strategy.

type Value = f64

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

fn new_tree(
    &self,
    runner: &mut TestRunner
) -> Result<<RangeTo<f64> as Strategy>::Tree, Reason>

Generate a new value tree from the given runner.

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.

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>.

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.

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.

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.

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.

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.

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.

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

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<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.

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

Shuffle the contents of the values produced by this strategy.

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.

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.

fn no_shrink(self) -> NoShrink<Self>

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

impl Strategy for RangeTo<i32>

type Tree = BinarySearch

The value tree generated by this Strategy.

type Value = i32

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

fn new_tree(
    &self,
    runner: &mut TestRunner
) -> Result<<RangeTo<i32> as Strategy>::Tree, Reason>

Generate a new value tree from the given runner.

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.

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>.

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.

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.

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.

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.

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.

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.

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

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<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.

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

Shuffle the contents of the values produced by this strategy.

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.

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.

fn no_shrink(self) -> NoShrink<Self>

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

impl Strategy for RangeTo<isize>

type Tree = BinarySearch

The value tree generated by this Strategy.

type Value = isize

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

fn new_tree(
    &self,
    runner: &mut TestRunner
) -> Result<<RangeTo<isize> as Strategy>::Tree, Reason>

Generate a new value tree from the given runner.

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.

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>.

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.

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.

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.

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.

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.

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.

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

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<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.

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

Shuffle the contents of the values produced by this strategy.

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.

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.

fn no_shrink(self) -> NoShrink<Self>

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

impl Strategy for RangeTo<u32>

type Tree = BinarySearch

The value tree generated by this Strategy.

type Value = u32

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

fn new_tree(
    &self,
    runner: &mut TestRunner
) -> Result<<RangeTo<u32> as Strategy>::Tree, Reason>

Generate a new value tree from the given runner.

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.

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>.

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.

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.

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.

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.

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.

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.

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

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<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.

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

Shuffle the contents of the values produced by this strategy.

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.

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.

fn no_shrink(self) -> NoShrink<Self>

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

impl Strategy for RangeTo<i128>

type Tree = BinarySearch

The value tree generated by this Strategy.

type Value = i128

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

fn new_tree(
    &self,
    runner: &mut TestRunner
) -> Result<<RangeTo<i128> as Strategy>::Tree, Reason>

Generate a new value tree from the given runner.

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.

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>.

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.

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.

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.

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.

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.

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.

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

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<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.

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

Shuffle the contents of the values produced by this strategy.

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.

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.

fn no_shrink(self) -> NoShrink<Self>

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

impl Strategy for RangeTo<u64>

type Tree = BinarySearch

The value tree generated by this Strategy.

type Value = u64

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

fn new_tree(
    &self,
    runner: &mut TestRunner
) -> Result<<RangeTo<u64> as Strategy>::Tree, Reason>

Generate a new value tree from the given runner.

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.

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>.

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.

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.

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.

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.

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.

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.

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

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<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.

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

Shuffle the contents of the values produced by this strategy.

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.

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.

fn no_shrink(self) -> NoShrink<Self>

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

impl Strategy for RangeTo<usize>

type Tree = BinarySearch

The value tree generated by this Strategy.

type Value = usize

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

fn new_tree(
    &self,
    runner: &mut TestRunner
) -> Result<<RangeTo<usize> as Strategy>::Tree, Reason>

Generate a new value tree from the given runner.

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.

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>.

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.

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.

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.

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.

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.

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.

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

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<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.

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

Shuffle the contents of the values produced by this strategy.

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.

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.

fn no_shrink(self) -> NoShrink<Self>

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

impl Strategy for RangeTo<i16>

type Tree = BinarySearch

The value tree generated by this Strategy.

type Value = i16

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

fn new_tree(
    &self,
    runner: &mut TestRunner
) -> Result<<RangeTo<i16> as Strategy>::Tree, Reason>

Generate a new value tree from the given runner.

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.

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>.

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.

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.

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.

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.

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.

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.

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

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<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.

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

Shuffle the contents of the values produced by this strategy.

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.

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.

fn no_shrink(self) -> NoShrink<Self>

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

impl Strategy for RangeTo<i64>

type Tree = BinarySearch

The value tree generated by this Strategy.

type Value = i64

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

fn new_tree(
    &self,
    runner: &mut TestRunner
) -> Result<<RangeTo<i64> as Strategy>::Tree, Reason>

Generate a new value tree from the given runner.

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.

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>.

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.

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.

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.

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.

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.

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.

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

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<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.

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

Shuffle the contents of the values produced by this strategy.

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.

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.

fn no_shrink(self) -> NoShrink<Self>

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

impl Strategy for RangeTo<u16>

type Tree = BinarySearch

The value tree generated by this Strategy.

type Value = u16

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

fn new_tree(
    &self,
    runner: &mut TestRunner
) -> Result<<RangeTo<u16> as Strategy>::Tree, Reason>

Generate a new value tree from the given runner.

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.

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>.

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.

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.

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.

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.

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.

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.

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

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<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.

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

Shuffle the contents of the values produced by this strategy.

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.

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.

fn no_shrink(self) -> NoShrink<Self>

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

impl Strategy for RangeTo<f32>

type Tree = BinarySearch

The value tree generated by this Strategy.

type Value = f32

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

fn new_tree(
    &self,
    runner: &mut TestRunner
) -> Result<<RangeTo<f32> as Strategy>::Tree, Reason>

Generate a new value tree from the given runner.

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.

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>.

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.

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.

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.

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.

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.

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.

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

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<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.

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

Shuffle the contents of the values produced by this strategy.

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.

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.

fn no_shrink(self) -> NoShrink<Self>

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

impl Strategy for RangeTo<u8>

type Tree = BinarySearch

The value tree generated by this Strategy.

type Value = u8

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

fn new_tree(
    &self,
    runner: &mut TestRunner
) -> Result<<RangeTo<u8> as Strategy>::Tree, Reason>

Generate a new value tree from the given runner.

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.

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>.

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.

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.

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.

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.

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.

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.

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

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<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.

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

Shuffle the contents of the values produced by this strategy.

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.

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.

fn no_shrink(self) -> NoShrink<Self>

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

impl Strategy for RangeTo<i8>

type Tree = BinarySearch

The value tree generated by this Strategy.

type Value = i8

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

fn new_tree(
    &self,
    runner: &mut TestRunner
) -> Result<<RangeTo<i8> as Strategy>::Tree, Reason>

Generate a new value tree from the given runner.

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.

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>.

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.

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.

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.

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.

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.

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.

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

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<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.

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

Shuffle the contents of the values produced by this strategy.

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.

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.

fn no_shrink(self) -> NoShrink<Self>

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

impl From<RangeTo<usize>> for SizeRange

Given ..high, then a size range [0, high) is the result.

fn from(high: RangeTo<usize>) -> SizeRange

Performs the conversion.

impl<A> Arbitrary for RangeTo<A> where
    A: Arbitrary, 

type Parameters = <A as Arbitrary>::Parameters

The type of parameters that [arbitrary_with] accepts for configuration of the generated [Strategy]. Parameters must implement [Default].

type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> RangeTo<A>>

The type of [Strategy] used to generate values of type Self.

fn arbitrary_with(
    args: <RangeTo<A> as Arbitrary>::Parameters
) -> <RangeTo<A> as Arbitrary>::Strategy

Generates a [Strategy] for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a [Strategy] for producing arbitrary values of type the implementing type (Self).

impl<A> ArbitraryF1<A> for RangeTo<A> where
    A: 'static + Debug, 

type Parameters = ()

The type of parameters that [lift1_with] accepts for configuration of the lifted and generated [Strategy]. Parameters must implement [Default].

fn lift1_with<S>(
    base: S,
    _args: <RangeTo<A> as ArbitraryF1<A>>::Parameters
) -> BoxedStrategy<RangeTo<A>> where
    S: Strategy<Value = A> + 'static, 

Lifts a given [Strategy] to a new [Strategy] for the (presumably) bigger type. This is useful for lifting a Strategy for SomeType to a container such as Vec of SomeType. The composite strategy is passed the arguments given in args.

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

Lifts a given [Strategy] to a new [Strategy] for the (presumably) bigger type. This is useful for lifting a Strategy for SomeType to a container such as Vec<SomeType>.