Struct 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      ]); // This is a `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).

Implementations

impl<Idx> RangeTo<Idx>

where Idx: PartialOrd,

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

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<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: Debug + 'static,

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

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<C1, C2> ContainsToken<C1> for RangeTo<C2>

where C1: AsChar, C2: AsChar + Clone,

fn contains_token(&self, token: C1) -> bool

Returns true if self contains the token

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<'de, Idx> Deserialize<'de> for RangeTo<Idx>

where Idx: Deserialize<'de>,

fn deserialize<D>( deserializer: D, ) -> Result<RangeTo<Idx>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<RangeTo<i64>> for ValueParser

Create an i64 ValueParser from a ..M range

See RangedI64ValueParser for more control over the output type.

See also RangedU64ValueParser

Examples

let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("port")
            .long("port")
            .value_parser(..3000)
            .action(clap::ArgAction::Set)
            .required(true)
    );

let m = cmd.try_get_matches_from_mut(["cmd", "--port", "80"]).unwrap();
let port: i64 = *m.get_one("port")
    .expect("required");
assert_eq!(port, 80);

fn from(value: RangeTo<i64>) -> ValueParser

Converts to this type from the input type.

impl From<RangeTo<usize>> for Range

fn from(range: RangeTo<usize>) -> Range

Converts to this type from the input type.

impl From<RangeTo<usize>> for SizeRange

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

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

Converts to this type from the input type.

impl From<RangeTo<usize>> for ValueRange

fn from(range: RangeTo<usize>) -> ValueRange

Converts to this type from the input type.

impl<Idx> Hash for RangeTo<Idx>

where Idx: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Index<RangeTo<Position>> for Url

type Output = str

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl Index<RangeTo<usize>> for BStr

type Output = BStr

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl Index<RangeTo<usize>> for BStr

type Output = BStr

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl Index<RangeTo<usize>> for Bytes

type Output = Bytes

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<K, V, S> Index<RangeTo<usize>> for IndexMap<K, V, S>

type Output = Slice<K, V>

The returned type after indexing.

fn index( &self, range: RangeTo<usize>, ) -> &<IndexMap<K, V, S> as Index<RangeTo<usize>>>::Output

Performs the indexing (container[index]) operation.

impl<T, S> Index<RangeTo<usize>> for IndexSet<T, S>

type Output = Slice<T>

The returned type after indexing.

fn index( &self, range: RangeTo<usize>, ) -> &<IndexSet<T, S> as Index<RangeTo<usize>>>::Output

Performs the indexing (container[index]) operation.

impl<K, V> Index<RangeTo<usize>> for Slice<K, V>

type Output = Slice<K, V>

The returned type after indexing.

fn index(&self, range: RangeTo<usize>) -> &Slice<K, V>

Performs the indexing (container[index]) operation.

impl<T> Index<RangeTo<usize>> for Slice<T>

type Output = Slice<T>

The returned type after indexing.

fn index( &self, range: RangeTo<usize>, ) -> &<Slice<T> as Index<RangeTo<usize>>>::Output

Performs the indexing (container[index]) operation.

impl Index<RangeTo<usize>> for UninitSlice

type Output = UninitSlice

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl IndexMut<RangeTo<usize>> for BStr

fn index_mut(&mut self, r: RangeTo<usize>) -> &mut BStr

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

impl<K, V, S> IndexMut<RangeTo<usize>> for IndexMap<K, V, S>

fn index_mut( &mut self, range: RangeTo<usize>, ) -> &mut <IndexMap<K, V, S> as Index<RangeTo<usize>>>::Output

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

impl<K, V> IndexMut<RangeTo<usize>> for Slice<K, V>

fn index_mut(&mut self, range: RangeTo<usize>) -> &mut Slice<K, V>

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

impl IndexMut<RangeTo<usize>> for UninitSlice

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

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

impl<I> IteratorIndex<I> for RangeTo<usize>

where I: Iterator,

type Output = Take<I>

The type returned for this type of index.

fn index(self, iter: I) -> <RangeTo<usize> as IteratorIndex<I>>::Output

Returns an adapted iterator for the current index.

impl<I> IteratorIndex<I> for RangeTo<usize>

where I: Iterator,

type Output = Take<I>

The type returned for this type of index.

fn index(self, iter: I) -> <RangeTo<usize> as IteratorIndex<I>>::Output

Returns an adapted iterator for the current index.

impl NomRange<usize> for RangeTo<usize>

type Saturating = Range<usize>

The saturating iterator type.

type Bounded = Range<usize>

The bounded iterator type.

fn bounds(&self) -> (Bound<usize>, Bound<usize>)

Returns the bounds of this range.

fn contains(&self, item: &usize) -> bool

true if item is contained in the range.

fn is_inverted(&self) -> bool

true if the range is inverted.

fn saturating_iter(&self) -> <RangeTo<usize> as NomRange<usize>>::Saturating

Creates a saturating iterator. A saturating iterator counts the number of iterations starting from 0 up to the upper bound of this range. If the upper bound is infinite the iterator saturates at the largest representable value of its type and returns it for all further elements.

fn bounded_iter(&self) -> <RangeTo<usize> as NomRange<usize>>::Bounded

Creates a bounded iterator. A bounded iterator counts the number of iterations starting from 0 up to the upper bound of this range. If the upper bounds is infinite the iterator counts up until the amount of iterations has reached the largest representable value of its type and then returns None for all further elements.

impl<Idx> PartialEq for RangeTo<Idx>

where Idx: PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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 SampleRange<u128> for RangeTo<u128>

fn sample_single<R>(self, rng: &mut R) -> Result<u128, Error>

where R: RngCore + ?Sized,

Generate a sample from the given range.

fn is_empty(&self) -> bool

Check whether the range is empty.

impl SampleRange<u16> for RangeTo<u16>

fn sample_single<R>(self, rng: &mut R) -> Result<u16, Error>

where R: RngCore + ?Sized,

Generate a sample from the given range.

fn is_empty(&self) -> bool

Check whether the range is empty.

impl SampleRange<u32> for RangeTo<u32>

fn sample_single<R>(self, rng: &mut R) -> Result<u32, Error>

where R: RngCore + ?Sized,

Generate a sample from the given range.

fn is_empty(&self) -> bool

Check whether the range is empty.

impl SampleRange<u64> for RangeTo<u64>

fn sample_single<R>(self, rng: &mut R) -> Result<u64, Error>

where R: RngCore + ?Sized,

Generate a sample from the given range.

fn is_empty(&self) -> bool

Check whether the range is empty.

impl SampleRange<u8> for RangeTo<u8>

fn sample_single<R>(self, rng: &mut R) -> Result<u8, Error>

where R: RngCore + ?Sized,

Generate a sample from the given range.

fn is_empty(&self) -> bool

Check whether the range is empty.

impl SampleRange<usize> for RangeTo<usize>

fn sample_single<R>(self, rng: &mut R) -> Result<usize, Error>

where R: RngCore + ?Sized,

Generate a sample from the given range.

fn is_empty(&self) -> bool

Check whether the range is empty.

impl<Idx> Serialize for RangeTo<Idx>

where Idx: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, T> Slice<RangeTo<usize>> for &'a [T]

fn slice(&self, range: RangeTo<usize>) -> &'a [T]

Slices self according to the range argument

impl<'a> Slice<RangeTo<usize>> for &'a str

fn slice(&self, range: RangeTo<usize>) -> &'a str

Slices self according to the range argument

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

The methods index and index_mut panic if the end of the range is out of bounds.

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: *const [T]) -> *const [T]

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

Returns a pointer 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 pointer 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 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: *const str, ) -> *const <RangeTo<usize> as SliceIndex<str>>::Output

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

Returns a pointer 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 pointer 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 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 O: Debug, F: Fn(Self::Value) -> O, Self: Sized,

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

fn prop_map_into<O>(self) -> MapInto<Self, O>

where O: Debug, Self: Sized, Self::Value: Into<O>,

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

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F>

where O: Debug, F: Fn(Self::Value, TestRng) -> O, Self: Sized,

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

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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 S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F>

where R: Into<Reason>, F: Fn(&Self::Value) -> bool, Self: Sized,

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F, O>( self, whence: impl Into<Reason>, fun: F, ) -> FilterMap<Self, F>

where F: Fn(Self::Value) -> Option<O>, O: Debug, Self: Sized,

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

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

where Self: Sized,

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F, ) -> Recursive<Self::Value, F>

where R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R, Self: Sized + 'static,

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self>

where Self: Sized, Self::Value: Shuffleable,

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value>

where Self: Sized + 'static,

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

fn sboxed(self) -> SBoxedStrategy<Self::Value>

where Self: Sized + Send + Sync + 'static,

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

fn no_shrink(self) -> NoShrink<Self>

where Self: Sized,

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

impl 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 O: Debug, F: Fn(Self::Value) -> O, Self: Sized,

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

fn prop_map_into<O>(self) -> MapInto<Self, O>

where O: Debug, Self: Sized, Self::Value: Into<O>,

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

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F>

where O: Debug, F: Fn(Self::Value, TestRng) -> O, Self: Sized,

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

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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 S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F>

where R: Into<Reason>, F: Fn(&Self::Value) -> bool, Self: Sized,

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F, O>( self, whence: impl Into<Reason>, fun: F, ) -> FilterMap<Self, F>

where F: Fn(Self::Value) -> Option<O>, O: Debug, Self: Sized,

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

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

where Self: Sized,

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F, ) -> Recursive<Self::Value, F>

where R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R, Self: Sized + 'static,

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self>

where Self: Sized, Self::Value: Shuffleable,

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value>

where Self: Sized + 'static,

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

fn sboxed(self) -> SBoxedStrategy<Self::Value>

where Self: Sized + Send + Sync + 'static,

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

fn no_shrink(self) -> NoShrink<Self>

where Self: Sized,

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

impl 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 O: Debug, F: Fn(Self::Value) -> O, Self: Sized,

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

fn prop_map_into<O>(self) -> MapInto<Self, O>

where O: Debug, Self: Sized, Self::Value: Into<O>,

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

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F>

where O: Debug, F: Fn(Self::Value, TestRng) -> O, Self: Sized,

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

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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 S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F>

where R: Into<Reason>, F: Fn(&Self::Value) -> bool, Self: Sized,

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F, O>( self, whence: impl Into<Reason>, fun: F, ) -> FilterMap<Self, F>

where F: Fn(Self::Value) -> Option<O>, O: Debug, Self: Sized,

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

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

where Self: Sized,

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F, ) -> Recursive<Self::Value, F>

where R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R, Self: Sized + 'static,

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self>

where Self: Sized, Self::Value: Shuffleable,

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value>

where Self: Sized + 'static,

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

fn sboxed(self) -> SBoxedStrategy<Self::Value>

where Self: Sized + Send + Sync + 'static,

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

fn no_shrink(self) -> NoShrink<Self>

where Self: Sized,

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

impl 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 O: Debug, F: Fn(Self::Value) -> O, Self: Sized,

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

fn prop_map_into<O>(self) -> MapInto<Self, O>

where O: Debug, Self: Sized, Self::Value: Into<O>,

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

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F>

where O: Debug, F: Fn(Self::Value, TestRng) -> O, Self: Sized,

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

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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 S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F>

where R: Into<Reason>, F: Fn(&Self::Value) -> bool, Self: Sized,

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F, O>( self, whence: impl Into<Reason>, fun: F, ) -> FilterMap<Self, F>

where F: Fn(Self::Value) -> Option<O>, O: Debug, Self: Sized,

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

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

where Self: Sized,

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F, ) -> Recursive<Self::Value, F>

where R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R, Self: Sized + 'static,

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self>

where Self: Sized, Self::Value: Shuffleable,

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value>

where Self: Sized + 'static,

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

fn sboxed(self) -> SBoxedStrategy<Self::Value>

where Self: Sized + Send + Sync + 'static,

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

fn no_shrink(self) -> NoShrink<Self>

where Self: Sized,

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

impl 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 O: Debug, F: Fn(Self::Value) -> O, Self: Sized,

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

fn prop_map_into<O>(self) -> MapInto<Self, O>

where O: Debug, Self: Sized, Self::Value: Into<O>,

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

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F>

where O: Debug, F: Fn(Self::Value, TestRng) -> O, Self: Sized,

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

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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 S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F>

where R: Into<Reason>, F: Fn(&Self::Value) -> bool, Self: Sized,

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F, O>( self, whence: impl Into<Reason>, fun: F, ) -> FilterMap<Self, F>

where F: Fn(Self::Value) -> Option<O>, O: Debug, Self: Sized,

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

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

where Self: Sized,

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F, ) -> Recursive<Self::Value, F>

where R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R, Self: Sized + 'static,

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self>

where Self: Sized, Self::Value: Shuffleable,

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value>

where Self: Sized + 'static,

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

fn sboxed(self) -> SBoxedStrategy<Self::Value>

where Self: Sized + Send + Sync + 'static,

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

fn no_shrink(self) -> NoShrink<Self>

where Self: Sized,

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

impl 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 O: Debug, F: Fn(Self::Value) -> O, Self: Sized,

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

fn prop_map_into<O>(self) -> MapInto<Self, O>

where O: Debug, Self: Sized, Self::Value: Into<O>,

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

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F>

where O: Debug, F: Fn(Self::Value, TestRng) -> O, Self: Sized,

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

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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 S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F>

where R: Into<Reason>, F: Fn(&Self::Value) -> bool, Self: Sized,

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F, O>( self, whence: impl Into<Reason>, fun: F, ) -> FilterMap<Self, F>

where F: Fn(Self::Value) -> Option<O>, O: Debug, Self: Sized,

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

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

where Self: Sized,

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F, ) -> Recursive<Self::Value, F>

where R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R, Self: Sized + 'static,

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self>

where Self: Sized, Self::Value: Shuffleable,

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value>

where Self: Sized + 'static,

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

fn sboxed(self) -> SBoxedStrategy<Self::Value>

where Self: Sized + Send + Sync + 'static,

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

fn no_shrink(self) -> NoShrink<Self>

where Self: Sized,

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

impl 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 O: Debug, F: Fn(Self::Value) -> O, Self: Sized,

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

fn prop_map_into<O>(self) -> MapInto<Self, O>

where O: Debug, Self: Sized, Self::Value: Into<O>,

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

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F>

where O: Debug, F: Fn(Self::Value, TestRng) -> O, Self: Sized,

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

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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 S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F>

where R: Into<Reason>, F: Fn(&Self::Value) -> bool, Self: Sized,

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F, O>( self, whence: impl Into<Reason>, fun: F, ) -> FilterMap<Self, F>

where F: Fn(Self::Value) -> Option<O>, O: Debug, Self: Sized,

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

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

where Self: Sized,

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F, ) -> Recursive<Self::Value, F>

where R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R, Self: Sized + 'static,

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self>

where Self: Sized, Self::Value: Shuffleable,

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value>

where Self: Sized + 'static,

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

fn sboxed(self) -> SBoxedStrategy<Self::Value>

where Self: Sized + Send + Sync + 'static,

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

fn no_shrink(self) -> NoShrink<Self>

where Self: Sized,

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

impl 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 O: Debug, F: Fn(Self::Value) -> O, Self: Sized,

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

fn prop_map_into<O>(self) -> MapInto<Self, O>

where O: Debug, Self: Sized, Self::Value: Into<O>,

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

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F>

where O: Debug, F: Fn(Self::Value, TestRng) -> O, Self: Sized,

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

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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 S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F>

where R: Into<Reason>, F: Fn(&Self::Value) -> bool, Self: Sized,

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F, O>( self, whence: impl Into<Reason>, fun: F, ) -> FilterMap<Self, F>

where F: Fn(Self::Value) -> Option<O>, O: Debug, Self: Sized,

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

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

where Self: Sized,

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F, ) -> Recursive<Self::Value, F>

where R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R, Self: Sized + 'static,

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self>

where Self: Sized, Self::Value: Shuffleable,

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value>

where Self: Sized + 'static,

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

fn sboxed(self) -> SBoxedStrategy<Self::Value>

where Self: Sized + Send + Sync + 'static,

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

fn no_shrink(self) -> NoShrink<Self>

where Self: Sized,

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

impl 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 O: Debug, F: Fn(Self::Value) -> O, Self: Sized,

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

fn prop_map_into<O>(self) -> MapInto<Self, O>

where O: Debug, Self: Sized, Self::Value: Into<O>,

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

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F>

where O: Debug, F: Fn(Self::Value, TestRng) -> O, Self: Sized,

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

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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 S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F>

where R: Into<Reason>, F: Fn(&Self::Value) -> bool, Self: Sized,

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F, O>( self, whence: impl Into<Reason>, fun: F, ) -> FilterMap<Self, F>

where F: Fn(Self::Value) -> Option<O>, O: Debug, Self: Sized,

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

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

where Self: Sized,

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F, ) -> Recursive<Self::Value, F>

where R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R, Self: Sized + 'static,

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self>

where Self: Sized, Self::Value: Shuffleable,

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value>

where Self: Sized + 'static,

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

fn sboxed(self) -> SBoxedStrategy<Self::Value>

where Self: Sized + Send + Sync + 'static,

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

fn no_shrink(self) -> NoShrink<Self>

where Self: Sized,

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

impl 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 O: Debug, F: Fn(Self::Value) -> O, Self: Sized,

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

fn prop_map_into<O>(self) -> MapInto<Self, O>

where O: Debug, Self: Sized, Self::Value: Into<O>,

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

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F>

where O: Debug, F: Fn(Self::Value, TestRng) -> O, Self: Sized,

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

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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 S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F>

where R: Into<Reason>, F: Fn(&Self::Value) -> bool, Self: Sized,

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F, O>( self, whence: impl Into<Reason>, fun: F, ) -> FilterMap<Self, F>

where F: Fn(Self::Value) -> Option<O>, O: Debug, Self: Sized,

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

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

where Self: Sized,

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F, ) -> Recursive<Self::Value, F>

where R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R, Self: Sized + 'static,

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self>

where Self: Sized, Self::Value: Shuffleable,

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value>

where Self: Sized + 'static,

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

fn sboxed(self) -> SBoxedStrategy<Self::Value>

where Self: Sized + Send + Sync + 'static,

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

fn no_shrink(self) -> NoShrink<Self>

where Self: Sized,

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

impl 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 O: Debug, F: Fn(Self::Value) -> O, Self: Sized,

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

fn prop_map_into<O>(self) -> MapInto<Self, O>

where O: Debug, Self: Sized, Self::Value: Into<O>,

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

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F>

where O: Debug, F: Fn(Self::Value, TestRng) -> O, Self: Sized,

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

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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 S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F>

where R: Into<Reason>, F: Fn(&Self::Value) -> bool, Self: Sized,

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F, O>( self, whence: impl Into<Reason>, fun: F, ) -> FilterMap<Self, F>

where F: Fn(Self::Value) -> Option<O>, O: Debug, Self: Sized,

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

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

where Self: Sized,

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F, ) -> Recursive<Self::Value, F>

where R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R, Self: Sized + 'static,

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self>

where Self: Sized, Self::Value: Shuffleable,

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value>

where Self: Sized + 'static,

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

fn sboxed(self) -> SBoxedStrategy<Self::Value>

where Self: Sized + Send + Sync + 'static,

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

fn no_shrink(self) -> NoShrink<Self>

where Self: Sized,

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

impl 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 O: Debug, F: Fn(Self::Value) -> O, Self: Sized,

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

fn prop_map_into<O>(self) -> MapInto<Self, O>

where O: Debug, Self: Sized, Self::Value: Into<O>,

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

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F>

where O: Debug, F: Fn(Self::Value, TestRng) -> O, Self: Sized,

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

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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 S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F>

where R: Into<Reason>, F: Fn(&Self::Value) -> bool, Self: Sized,

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F, O>( self, whence: impl Into<Reason>, fun: F, ) -> FilterMap<Self, F>

where F: Fn(Self::Value) -> Option<O>, O: Debug, Self: Sized,

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

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

where Self: Sized,

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F, ) -> Recursive<Self::Value, F>

where R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R, Self: Sized + 'static,

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self>

where Self: Sized, Self::Value: Shuffleable,

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value>

where Self: Sized + 'static,

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

fn sboxed(self) -> SBoxedStrategy<Self::Value>

where Self: Sized + Send + Sync + 'static,

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

fn no_shrink(self) -> NoShrink<Self>

where Self: Sized,

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

impl 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 O: Debug, F: Fn(Self::Value) -> O, Self: Sized,

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

fn prop_map_into<O>(self) -> MapInto<Self, O>

where O: Debug, Self: Sized, Self::Value: Into<O>,

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

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F>

where O: Debug, F: Fn(Self::Value, TestRng) -> O, Self: Sized,

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

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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 S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F>

where R: Into<Reason>, F: Fn(&Self::Value) -> bool, Self: Sized,

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F, O>( self, whence: impl Into<Reason>, fun: F, ) -> FilterMap<Self, F>

where F: Fn(Self::Value) -> Option<O>, O: Debug, Self: Sized,

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

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

where Self: Sized,

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F, ) -> Recursive<Self::Value, F>

where R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R, Self: Sized + 'static,

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self>

where Self: Sized, Self::Value: Shuffleable,

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value>

where Self: Sized + 'static,

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

fn sboxed(self) -> SBoxedStrategy<Self::Value>

where Self: Sized + Send + Sync + 'static,

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

fn no_shrink(self) -> NoShrink<Self>

where Self: Sized,

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

impl 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 O: Debug, F: Fn(Self::Value) -> O, Self: Sized,

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

fn prop_map_into<O>(self) -> MapInto<Self, O>

where O: Debug, Self: Sized, Self::Value: Into<O>,

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

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F>

where O: Debug, F: Fn(Self::Value, TestRng) -> O, Self: Sized,

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

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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 S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

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

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F>

where R: Into<Reason>, F: Fn(&Self::Value) -> bool, Self: Sized,

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F, O>( self, whence: impl Into<Reason>, fun: F, ) -> FilterMap<Self, F>

where F: Fn(Self::Value) -> Option<O>, O: Debug, Self: Sized,

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

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

where Self: Sized,

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F, ) -> Recursive<Self::Value, F>

where R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R, Self: Sized + 'static,

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self>

where Self: Sized, Self::Value: Shuffleable,

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value>

where Self: Sized + 'static,

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

fn sboxed(self) -> SBoxedStrategy<Self::Value>

where Self: Sized + Send + Sync + 'static,

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

fn no_shrink(self) -> NoShrink<Self>

where Self: Sized,

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

impl<'data> TryFrom<&RangeTo<char>> for CodePointInversionList<'data>

type Error = CodePointInversionListError

The type returned in the event of a conversion error.

fn try_from( range: &RangeTo<char>, ) -> Result<CodePointInversionList<'data>, <CodePointInversionList<'data> as TryFrom<&RangeTo<char>>>::Error>

Performs the conversion.

impl<Idx> Copy for RangeTo<Idx>

where Idx: Copy,

impl<Idx> Eq for RangeTo<Idx>

where Idx: Eq,

impl<T> OneSidedRange<T> for RangeTo<T>

where RangeTo<T>: RangeBounds<T>,

impl<Idx> StructuralPartialEq for RangeTo<Idx>