Struct checkito::same::Same

pub struct Same<T: ?Sized>(pub T);

Tuple Fields

0: T

Trait Implementations

impl<T: Clone + ?Sized> Clone for Same<T>

fn clone(&self) -> Same<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ?Sized> Debug for Same<T>

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

Formats the value using the given formatter.

impl<T: Default + ?Sized> Default for Same<T>

fn default() -> Same<T>

Returns the “default value” for a type.

impl<T: Default + Clone> FullGenerate for Same<T>

type Item = T

type Generate = Same<T>

fn generator() -> Self::Generate

impl<T: Clone> FullShrink for Same<T>

type Item = T

type Shrink = Same<T>

fn shrinker(item: Self::Item) -> Option<Self::Shrink>

impl<T: Clone> Generate for Same<T>

type Item = T

type Shrink = Same<T>

fn generate(&self, _: &mut State) -> Self::Shrink

Primary method of this trait. It generates a Shrink instance that will be able to produce values of type Generate::Item and shrink itself.

fn boxed(self) -> Generator<Self::Item>

where Self: Sized + 'static, Generator<Self::Item>: Generate,

Wraps self in a boxed Generate. This is notably relevant for recursive Generate implementations where the type would otherwise be infinite.

fn map<T, F: Fn(Self::Item) -> T>(self, map: F) -> Map<Self, F>

where Self: Sized, Map<Self, F>: Generate,

Maps generated Generate::Item to an arbitrary type T using the provided function F.

fn filter<F: Fn(&Self::Item) -> bool>(self, filter: F) -> Filter<Self, F>

where Self: Sized, Filter<Self, F>: Generate,

Same as Generate::filter_with but with a predefined number of retries.

fn filter_with<F: Fn(&Self::Item) -> bool>( self, retries: usize, filter: F, ) -> Filter<Self, F>

where Self: Sized, Filter<Self, F>: Generate,

Generates many Generate::Item with an increasingly large size until the filter function F is satisfied, up to the maximum number of retries.

fn filter_map<T, F: Fn(Self::Item) -> Option<T>>( self, map: F, ) -> FilterMap<Self, F>

where Self: Sized, FilterMap<Self, F>: Generate,

Same as Generate::filter_map_with but with a predefined number of retries.

fn filter_map_with<T, F: Fn(Self::Item) -> Option<T>>( self, retries: usize, map: F, ) -> FilterMap<Self, F>

where Self: Sized, FilterMap<Self, F>: Generate,

Combines Generate::map and Generate::filter in a single Generate implementation where the map function is considered to satisfy the filter when a [Some(T)] is produced.

fn flat_map<G: Generate, F: Fn(Self::Item) -> G>( self, map: F, ) -> Flatten<Map<Self, F>>

where Self: Sized, Map<Self, F>: Generate<Item = G>, Flatten<Map<Self, F>>: Generate,

Combines Generate::map and Generate::flatten in a single Generate implementation.

fn array<const N: usize>(self) -> Array<Self, N>

where Self: Sized, Array<Self, N>: Generate,

Generates N items and fills an array with it.

fn collect<F: FromIterator<Self::Item>>(self) -> Collect<Self, Range<usize>, F>

where Self: Sized, Collect<Self, Range<usize>, F>: Generate,

Same as Generate::collect_with but with a predefined count.

fn collect_with<C: Generate<Item = usize>, F: FromIterator<Self::Item>>( self, count: C, ) -> Collect<Self, C, F>

where Self: Sized, Collect<Self, C, F>: Generate,

Generates a variable number of items based on the provided count Generate and then builds a value of type F based on its implementation of FromIterator.

fn size<F: Fn(f64, usize) -> f64>(self, map: F) -> Size<Self, F>

where Self: Sized, Size<Self, F>: Generate,

Maps the current size of the generation process to a different one. The size is a value in the range [0.0..1.0] that represents how big the generated items are based on the generator’s constraints. The generation process will initially try to produce small items and then move on to bigger ones. Note that the size does not guarantee a small or big generated item since Generate implementations are free to interpret it as they wish, although that is its intention.

fn dampen(self) -> Dampen<Self>

where Self: Sized, Size<Self>: Generate,

Same as Generate::dampen_with but with predefined arguments.

fn dampen_with( self, pressure: f64, deepest: usize, limit: usize, ) -> Dampen<Self>

where Self: Sized, Dampen<Self>: Generate,

Dampens the size (see Generate::size for more information about size) as items are generated.

fn keep(self) -> Keep<Self>

where Self: Sized, Keep<Self>: Generate,

Keeps the generated items intact through the shrinking process (i.e. un-shrinked).

fn sampler(&self) -> Sampler<'_, Self>

Provides a Sampler that allows to configure sampling settings and generate samples.

fn samples(&self, count: usize) -> Samples<'_, Self>

Generates count random values the are progressively larger in size. For additional sampling settings, see Generate::sampler.

fn sample(&self, size: f64) -> Self::Item

Generates a random value of size (0.0..=1.0). For additional sampling settings, see Generate::sampler.

fn checker(&self) -> Checker<'_, Self>

fn checks<P: Prove, F: FnMut(&Self::Item) -> P>( &self, count: usize, check: F, ) -> Checks<'_, Self, F>

fn check<P: Prove, F: FnMut(&Self::Item) -> P>( &self, count: usize, check: F, ) -> Result<(), Error<Self::Item, P>>

impl<T: Clone> IntoShrink for Same<T>

type Item = T

type Shrink = Same<T>

fn shrinker(&self, item: Self::Item) -> Option<Self::Shrink>

impl<T: Clone> Shrink for Same<T>

type Item = T

fn item(&self) -> Self::Item

fn shrink(&mut self) -> Option<Self>

fn boxed(self) -> Shrinker<Self::Item>

where Self: 'static,