Struct TupleStrategy3 

pub struct TupleStrategy3<A, B, C> { /* private fields */ }

Implementations

impl<A, B, C> TupleStrategy3<A, B, C>

pub fn new() -> Self

Trait Implementations

impl<A: Clone, B: Clone, C: Clone> Clone for TupleStrategy3<A, B, C>

fn clone(&self) -> TupleStrategy3<A, B, C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug, B: Debug, C: Debug> Debug for TupleStrategy3<A, B, C>

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

Formats the value using the given formatter.

impl<A, B, C> Default for TupleStrategy3<A, B, C>

fn default() -> Self

Returns the “default value” for a type.

impl<A: Arbitrary + Clone + 'static, B: Arbitrary + Clone + 'static, C: Arbitrary + Clone + 'static> Generator<(A, B, C)> for TupleStrategy3<A, B, C>

fn generate( &self, _rng: &mut dyn RngCore, config: &GeneratorConfig, ) -> (A, B, C)

Generate a random value of type T using the provided RNG and configuration

fn shrink(&self, value: &(A, B, C)) -> Box<dyn Iterator<Item = (A, B, C)>>

Create an iterator of shrunk values from the given value

impl<A: Arbitrary + Clone + 'static, B: Arbitrary + Clone + 'static, C: Arbitrary + Clone + 'static> Strategy for TupleStrategy3<A, B, C>

type Value = (A, B, C)

The type of values this strategy generates

fn generate<R: Rng>(&self, rng: &mut R, config: &GeneratorConfig) -> (A, B, C)

Generate a value using this strategy

fn shrink(&self, value: &(A, B, C)) -> Box<dyn Iterator<Item = (A, B, C)>>

Create an iterator of shrunk values from the given value

fn map<F, U>(self, f: F) -> Map<Self, F>

where Self: Sized, F: Fn(Self::Value) -> U, U: 'static,

Map this strategy to produce values of a different type

fn filter<F>(self, predicate: F) -> Filter<Self, F>

where Self: Sized, F: Fn(&Self::Value) -> bool,

Filter values produced by this strategy

fn zip<S>(self, other: S) -> Zip<Self, S>

where Self: Sized, S: Strategy,

Combine this strategy with another to produce tuples

fn flat_map<F, S>(self, f: F) -> FlatMap<Self, F>

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

Flat map (bind) this strategy with a function that produces another strategy This is the most powerful combinator but also the trickiest for shrinking