Struct Map 

pub struct Map<S, F> { /* private fields */ }

A strategy that maps values from one type to another

To enable proper shrinking through map, we need to store the original input alongside the mapped output. This is done using MappedValue.

Trait Implementations

impl<S, F, U> Strategy for Map<S, F>

where S: Strategy, F: Fn(S::Value) -> U + Clone + 'static, U: 'static, S::Value: Clone,

type Value = MappedValue<<S as Strategy>::Value, U>

The type of values this strategy generates

fn generate<R: Rng>(&self, rng: &mut R, config: &GeneratorConfig) -> Self::Value

Generate a value using this strategy

fn shrink(&self, value: &Self::Value) -> Box<dyn Iterator<Item = Self::Value>>

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