Trait proptest_arbitrary::Arbitrary

pub trait Arbitrary<'a>: Sized + Debug {
    type Parameters: Default;
    type Strategy: Strategy<Value = Self::ValueTree>;
    type ValueTree: ValueTree<Value = Self>;
    fn arbitrary_with(args: Self::Parameters) -> Self::Strategy;

    fn arbitrary() -> Self::Strategy { ... }
}

Arbitrary determines a canonical Strategy for the implementing type.

It provides the function arbitrary which generates a Strategy for producing arbitrary values of the implementing type (Self).

This trait is the equivalent of Haskell QuickCheck's implementation of Arbitrary. In this interpretation of Arbitray, Strategy is the equivalent of the Gen monad.

Arbitrary currently only works for types which represent owned data as opposed to borrowed data. This is a fundamental restriction of proptest which may be lifted in the future as the generic associated types (GAT) feature of Rust is implemented and stabilized.

Associated Types

type Parameters: Default

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

type Strategy: Strategy<Value = Self::ValueTree>

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

type ValueTree: ValueTree<Value = Self>

The type of ValueTree used for Self's Strategy.

NOTE: This type should NOT be relied upon outside of this crate other than for implementing Arbitrary for other types.

Required Methods

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

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

If you wish to use the default() arguments, use arbitrary instead.

Provided Methods

fn arbitrary() -> Self::Strategy

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

Calling this for the type X is the equivalent of using X::arbitrary_with(Default::default()).

Implementations on Foreign Types

impl<'a> Arbitrary<'a> for bool

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Any

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for f32

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Any

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for f64

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Any

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for i8

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Any

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for i16

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Any

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for i32

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Any

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for i64

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Any

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for isize

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Any

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for u8

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Any

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for u16

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Any

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for u32

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Any

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for u64

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Any

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for usize

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Any

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for char

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = CharParam<'a>

type Strategy = CharStrategy<'a>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for EscapeDefault

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ParamsType<'a, u8>

type Strategy = SMapped<'a, u8, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Box<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = FMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Copy> Arbitrary<'a> for Cell<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = FMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for RefCell<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = FMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for UnsafeCell<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = FMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for BorrowError

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for BorrowMutError

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for EscapeDebug

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ParamsType<'a, char>

type Strategy = SMapped<'a, char, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for EscapeDefault

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ParamsType<'a, char>

type Strategy = SMapped<'a, char, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for EscapeUnicode

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ParamsType<'a, char>

type Strategy = SMapped<'a, char, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for ParseCharError

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = IndFlatten<Mapped<'a, bool, Just<Self>>>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for DecodeUtf16Error

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMap<Range<u16>, SFnMap<ValueFor<Range<u16>>, Self>>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Reverse<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Ordering

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<(W<Just<Ordering>>, W<Just<Ordering>>, W<Just<Ordering>>)>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Vec<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<SizeBounds, HCons<A::Parameters, HNil>>

type Strategy = VecStrategy<A::Strategy>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Box<[A]>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = <Vec<A> as Arbitrary<'a>>::Parameters

type Strategy = FMapped<'a, Vec<A>, Self>

fn arbitrary_with(a: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Rc<[A]>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = <Vec<A> as Arbitrary<'a>>::Parameters

type Strategy = FMapped<'a, Vec<A>, Self>

fn arbitrary_with(a: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Arc<[A]>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = <Vec<A> as Arbitrary<'a>>::Parameters

type Strategy = FMapped<'a, Vec<A>, Self>

fn arbitrary_with(a: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for VecDeque<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<SizeBounds, HCons<A::Parameters, HNil>>

type Strategy = VecDequeStrategy<A::Strategy>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for LinkedList<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<SizeBounds, HCons<A::Parameters, HNil>>

type Strategy = LinkedListStrategy<A::Strategy>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Ord> Arbitrary<'a> for BTreeSet<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<SizeBounds, HCons<A::Parameters, HNil>>

type Strategy = BTreeSetStrategy<A::Strategy>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Ord> Arbitrary<'a> for BinaryHeap<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<SizeBounds, HCons<A::Parameters, HNil>>

type Strategy = BinaryHeapStrategy<A::Strategy>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Hash + Eq> Arbitrary<'a> for HashSet<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<SizeBounds, HCons<A::Parameters, HNil>>

type Strategy = HashSetStrategy<A::Strategy>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Hash + Eq, B: Arbitrary<'a>> Arbitrary<'a> for HashMap<A, B>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<SizeBounds, HCons<A::Parameters, HCons<B::Parameters, HNil>>>

type Strategy = HashMapStrategy<A::Strategy, B::Strategy>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A, B> Arbitrary<'a> for BTreeMap<A, B> where
    A: Arbitrary<'static> + Ord,
    B: Arbitrary<'static>,
    StrategyFor<A>: 'static,
    StrategyFor<B>: 'static, 

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<SizeBounds, HCons<A::Parameters, HCons<B::Parameters, HNil>>>

type Strategy = BTreeMapStrategy<A::Strategy, B::Strategy>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for IntoIter<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = <Vec<A> as Arbitrary<'a>>::Parameters

type Strategy = SMapped<'a, Vec<A>, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for IntoIter<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = <VecDeque<A> as Arbitrary<'a>>::Parameters

type Strategy = SMapped<'a, VecDeque<A>, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for IntoIter<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = <LinkedList<A> as Arbitrary<'a>>::Parameters

type Strategy = SMapped<'a, LinkedList<A>, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Ord> Arbitrary<'a> for IntoIter<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = <BTreeSet<A> as Arbitrary<'a>>::Parameters

type Strategy = SMapped<'a, BTreeSet<A>, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Ord> Arbitrary<'a> for IntoIter<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = <BinaryHeap<A> as Arbitrary<'a>>::Parameters

type Strategy = SMapped<'a, BinaryHeap<A>, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Hash + Eq> Arbitrary<'a> for IntoIter<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = <HashSet<A> as Arbitrary<'a>>::Parameters

type Strategy = SMapped<'a, HashSet<A>, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Hash + Eq, B: Arbitrary<'a>> Arbitrary<'a> for IntoIter<A, B>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = <HashMap<A, B> as Arbitrary<'a>>::Parameters

type Strategy = SMapped<'a, HashMap<A, B>, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A, B> Arbitrary<'a> for IntoIter<A, B> where
    A: Arbitrary<'static> + Ord,
    B: Arbitrary<'static>,
    StrategyFor<A>: 'static,
    StrategyFor<B>: 'static, 

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = <BTreeMap<A, B> as Arbitrary<'a>>::Parameters

type Strategy = SMapped<'a, BTreeMap<A, B>, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Clone> Arbitrary<'a> for Bound<A> where
    ParamsType<'a, A>: Clone, 

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = TupleUnion<(W<SMapped<'a, A, Self>>, W<SMapped<'a, A, Self>>, W<Just<Self>>)>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Args

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for ArgsOs

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Vars

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for VarsOs

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for JoinPathsError

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for VarError

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<(W<Just<Self>>, W<SMap<BoxedStrategy<OsString>, SFnMap<ValueFor<BoxedStrategy<OsString>>, Self>>>)>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for CString

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = SizeBounds

type Strategy = SMap<VecStrategy<Range<u8>>, SFnMap<ValueFor<VecStrategy<Range<u8>>>, Self>>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for OsString

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = <String as Arbitrary<'a>>::Parameters

type Strategy = FMapped<'a, String, Self>

fn arbitrary_with(a: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Box<CStr>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = SizeBounds

type Strategy = FMapped<'a, CString, Self>

fn arbitrary_with(a: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Box<OsStr>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = <String as Arbitrary<'a>>::Parameters

type Strategy = FMapped<'a, OsString, Self>

fn arbitrary_with(a: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for FromBytesWithNulError

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMapped<'a, Option<u16>, Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for IntoStringError

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMap<BoxedStrategy<Vec<u8>>, SFnMap<ValueFor<BoxedStrategy<Vec<u8>>>, Self>>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Error

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Just<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for DirBuilder

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMapped<'a, bool, Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, H: Default + Hasher> Arbitrary<'a> for BuildHasherDefault<H>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Just<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for DefaultHasher

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for RandomState

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Read> Arbitrary<'a> for BufReader<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, (A, Option<u16>), Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Write> Arbitrary<'a> for BufWriter<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, (A, Option<u16>), Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Write> Arbitrary<'a> for LineWriter<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, (A, Option<u16>), Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Read + Arbitrary<'a>, B: Read + Arbitrary<'a>> Arbitrary<'a> for Chain<A, B>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<A::Parameters, HCons<B::Parameters, HNil>>

type Strategy = SMapped<'a, (A, B), Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Cursor<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Empty

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Sink

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Stderr

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Stdin

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Stdout

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + BufRead> Arbitrary<'a> for Lines<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Repeat

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMapped<'a, u8, Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: BufRead + Arbitrary<'a>> Arbitrary<'a> for Split<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, (A, u8), Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Read + Arbitrary<'a>> Arbitrary<'a> for Take<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, (A, u64), Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for ErrorKind

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Union<Just<Self>>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for SeekFrom

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<(W<SMapped<'a, u64, SeekFrom>>, W<SMapped<'a, i64, SeekFrom>>, W<SMapped<'a, i64, SeekFrom>>)>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Error

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMapped<'a, (ErrorKind, Option<String>), Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Once<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Clone> Arbitrary<'a> for Repeat<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Iterator<Item = &'a T>, T: 'a + Clone> Arbitrary<'a> for Cloned<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Iterator + Clone> Arbitrary<'a> for Cycle<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Iterator> Arbitrary<'a> for Enumerate<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Iterator> Arbitrary<'a> for Fuse<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Iterator<Item = T>, T: Debug> Arbitrary<'a> for Peekable<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + DoubleEndedIterator> Arbitrary<'a> for Rev<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A> Arbitrary<'a> for Empty<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Just<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Iterator, B: Arbitrary<'a> + Iterator> Arbitrary<'a> for Zip<A, B>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<A::Parameters, HCons<B::Parameters, HNil>>

type Strategy = SMapped<'a, (A, B), Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, T, A: Arbitrary<'a> + Iterator<Item = T>, B: Arbitrary<'a> + Iterator<Item = T>> Arbitrary<'a> for Chain<A, B>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<A::Parameters, HCons<B::Parameters, HNil>>

type Strategy = SMapped<'a, (A, B), Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Iterator> Arbitrary<'a> for Skip<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, (A, usize), Self>

fn arbitrary_with(a: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a> + Iterator> Arbitrary<'a> for Take<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, (A, usize), Self>

fn arbitrary_with(a: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, T: ?Sized> Arbitrary<'a> for PhantomData<T>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Just<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Discriminant<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for ManuallyDrop<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for AddrParseError

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Just<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Ipv4Addr

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<(W<Just<Self>>, W<Just<Self>>, W<FMapped<'a, u32, Self>>)>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Ipv6Addr

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<(W<SMapped<'a, Ipv4Addr, Self>>, W<FMapped<'a, [u16; 8], Self>>)>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for SocketAddrV4

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMapped<'a, (Ipv4Addr, u16), Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for SocketAddrV6

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMapped<'a, (Ipv6Addr, u16, u32, u32), Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for IpAddr

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<(W<FMapped<'a, Ipv4Addr, Self>>, W<FMapped<'a, Ipv6Addr, Self>>)>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Shutdown

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<(W<Just<Self>>, W<Just<Self>>, W<Just<Self>>)>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for SocketAddr

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<(W<FMapped<'a, SocketAddrV4, Self>>, W<FMapped<'a, SocketAddrV6, Self>>)>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for ParseFloatError

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Just<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for ParseIntError

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Just<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Wrapping<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for FpCategory

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<(W<Just<Self>>, W<Just<Self>>, W<Just<Self>>, W<Just<Self>>, W<Just<Self>>)>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for RangeFull

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Just<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for RangeFrom<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for RangeTo<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: PartialOrd + Arbitrary<'a>> Arbitrary<'a> for Range<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<A::Parameters, HCons<A::Parameters, HNil>>

type Strategy = SMapped<'a, (A, A), Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Option<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<Probability, HCons<A::Parameters, HNil>>

type Strategy = OptionStrategy<A::Strategy>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for IntoIter<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = <Option<A> as Arbitrary<'a>>::Parameters

type Strategy = SMapped<'a, Option<A>, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for AssertUnwindSafe<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for StripPrefixError

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Just<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Rc<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = FMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>, B: Arbitrary<'a>> Arbitrary<'a> for Result<A, B>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<Probability, HCons<A::Parameters, HCons<B::Parameters, HNil>>>

type Strategy = MaybeOk<A::Strategy, B::Strategy>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for IntoIter<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = <Result<A, ()> as Arbitrary<'a>>::Parameters

type Strategy = SMapped<'a, Result<A, ()>, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for ParseBoolError

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Just<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Utf8Error

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMap<(StrategyType<'a, u16>, TupleUnion<(W<Just<&'static [u8]>>, W<Just<&'static [u8]>>, W<Just<&'static [u8]>>, W<Just<&'static [u8]>>)>), SFnMap<ValueFor<(StrategyType<'a, u16>, TupleUnion<(W<Just<&'static [u8]>>, W<Just<&'static [u8]>>, W<Just<&'static [u8]>>, W<Just<&'static [u8]>>)>)>, Utf8Error>>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for String

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = StringParam<'a>

type Strategy = &'a str

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

Safety

This implementation panics if the input is not a valid regex proptest can handle.

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Box<str>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = StringParam<'a>

type Strategy = FMapped<'a, String, Self>

fn arbitrary_with(a: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Rc<str>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = StringParam<'a>

type Strategy = FMapped<'a, String, Self>

fn arbitrary_with(a: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Arc<str>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = StringParam<'a>

type Strategy = FMapped<'a, String, Self>

fn arbitrary_with(a: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for FromUtf16Error

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for FromUtf8Error

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMap<BoxedStrategy<Vec<u8>>, SFnMap<ValueFor<BoxedStrategy<Vec<u8>>>, Self>>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Arc<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = FMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Mutex<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for RwLock<A>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = SMapped<'a, A, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Barrier

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMapped<'a, u16, Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for BarrierWaitResult

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<(W<FnGenerator<Self>>, W<FnGenerator<Self>>)>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Condvar

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Once

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for WaitTimeoutResult

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<(W<Just<Self>>, W<Just<Self>>)>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for AtomicBool

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMapped<'a, bool, Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for AtomicIsize

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMapped<'a, isize, Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for AtomicUsize

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMapped<'a, usize, Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Ordering

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<(W<Just<Self>>, W<Just<Self>>, W<Just<Self>>, W<Just<Self>>, W<Just<Self>>)>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for RecvError

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Just<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, T: Arbitrary<'a>> Arbitrary<'a> for SendError<T>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = T::Parameters

type Strategy = SMapped<'a, T, Self>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for RecvTimeoutError

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<(W<Just<Self>>, W<Just<Self>>)>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for TryRecvError

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<(W<Just<Self>>, W<Just<Self>>)>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, P: Clone + Default, T: Arbitrary<'a, Parameters = P>> Arbitrary<'a> for TrySendError<T>

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = P

type Strategy = TupleUnion<(W<SMapped<'a, T, Self>>, W<SMapped<'a, T, Self>>)>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A> Arbitrary<'a> for (Sender<A>, Receiver<A>)

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Debug> Arbitrary<'a> for (Sender<A>, IntoIter<A>)

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = FnGenerator<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A> Arbitrary<'a> for (SyncSender<A>, Receiver<A>)

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMapped<'a, u16, Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Debug> Arbitrary<'a> for (SyncSender<A>, IntoIter<A>)

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMapped<'a, u16, Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Builder

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMapped<'a, (Option<usize>, Option<String>), Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Duration

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = SMapped<'a, (u64, u32), Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for Instant

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Just<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for SystemTime

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Just<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 1]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 1]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 2]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 2]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 3]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 3]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 4]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 4]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 5]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 5]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 6]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 6]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 7]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 7]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 8]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 8]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 9]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 9]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 10]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 10]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 11]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 11]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 12]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 12]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 13]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 13]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 14]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 14]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 15]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 15]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 16]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 16]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 17]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 17]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 18]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 18]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 19]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 19]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 20]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 20]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 21]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 21]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 22]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 22]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 23]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 23]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 24]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 24]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 25]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 25]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 26]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 26]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 27]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 27]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 28]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 28]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 29]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 29]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 30]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 30]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 31]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 31]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 32]

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = A::Parameters

type Strategy = UniformArrayStrategy<A::Strategy, [A; 32]>

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a> Arbitrary<'a> for ()

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Just<Self>

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, T0: Arbitrary<'a>> Arbitrary<'a> for (T0,)

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<T0::Parameters, HNil>

type Strategy = (T0::Strategy,)

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, T0: Arbitrary<'a>, T1: Arbitrary<'a>> Arbitrary<'a> for (T0, T1)

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<T0::Parameters, HCons<T1::Parameters, HNil>>

type Strategy = (T0::Strategy, T1::Strategy)

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, T0: Arbitrary<'a>, T1: Arbitrary<'a>, T2: Arbitrary<'a>> Arbitrary<'a> for (T0, T1, T2)

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<T0::Parameters, HCons<T1::Parameters, HCons<T2::Parameters, HNil>>>

type Strategy = (T0::Strategy, T1::Strategy, T2::Strategy)

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, T0: Arbitrary<'a>, T1: Arbitrary<'a>, T2: Arbitrary<'a>, T3: Arbitrary<'a>> Arbitrary<'a> for (T0, T1, T2, T3)

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<T0::Parameters, HCons<T1::Parameters, HCons<T2::Parameters, HCons<T3::Parameters, HNil>>>>

type Strategy = (T0::Strategy, T1::Strategy, T2::Strategy, T3::Strategy)

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, T0: Arbitrary<'a>, T1: Arbitrary<'a>, T2: Arbitrary<'a>, T3: Arbitrary<'a>, T4: Arbitrary<'a>> Arbitrary<'a> for (T0, T1, T2, T3, T4)

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<T0::Parameters, HCons<T1::Parameters, HCons<T2::Parameters, HCons<T3::Parameters, HCons<T4::Parameters, HNil>>>>>

type Strategy = (T0::Strategy, T1::Strategy, T2::Strategy, T3::Strategy, T4::Strategy)

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, T0: Arbitrary<'a>, T1: Arbitrary<'a>, T2: Arbitrary<'a>, T3: Arbitrary<'a>, T4: Arbitrary<'a>, T5: Arbitrary<'a>> Arbitrary<'a> for (T0, T1, T2, T3, T4, T5)

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<T0::Parameters, HCons<T1::Parameters, HCons<T2::Parameters, HCons<T3::Parameters, HCons<T4::Parameters, HCons<T5::Parameters, HNil>>>>>>

type Strategy = (T0::Strategy, T1::Strategy, T2::Strategy, T3::Strategy, T4::Strategy, T5::Strategy)

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, T0: Arbitrary<'a>, T1: Arbitrary<'a>, T2: Arbitrary<'a>, T3: Arbitrary<'a>, T4: Arbitrary<'a>, T5: Arbitrary<'a>, T6: Arbitrary<'a>> Arbitrary<'a> for (T0, T1, T2, T3, T4, T5, T6)

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<T0::Parameters, HCons<T1::Parameters, HCons<T2::Parameters, HCons<T3::Parameters, HCons<T4::Parameters, HCons<T5::Parameters, HCons<T6::Parameters, HNil>>>>>>>

type Strategy = (T0::Strategy, T1::Strategy, T2::Strategy, T3::Strategy, T4::Strategy, T5::Strategy, T6::Strategy)

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, T0: Arbitrary<'a>, T1: Arbitrary<'a>, T2: Arbitrary<'a>, T3: Arbitrary<'a>, T4: Arbitrary<'a>, T5: Arbitrary<'a>, T6: Arbitrary<'a>, T7: Arbitrary<'a>> Arbitrary<'a> for (T0, T1, T2, T3, T4, T5, T6, T7)

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<T0::Parameters, HCons<T1::Parameters, HCons<T2::Parameters, HCons<T3::Parameters, HCons<T4::Parameters, HCons<T5::Parameters, HCons<T6::Parameters, HCons<T7::Parameters, HNil>>>>>>>>

type Strategy = (T0::Strategy, T1::Strategy, T2::Strategy, T3::Strategy, T4::Strategy, T5::Strategy, T6::Strategy, T7::Strategy)

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, T0: Arbitrary<'a>, T1: Arbitrary<'a>, T2: Arbitrary<'a>, T3: Arbitrary<'a>, T4: Arbitrary<'a>, T5: Arbitrary<'a>, T6: Arbitrary<'a>, T7: Arbitrary<'a>, T8: Arbitrary<'a>> Arbitrary<'a> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<T0::Parameters, HCons<T1::Parameters, HCons<T2::Parameters, HCons<T3::Parameters, HCons<T4::Parameters, HCons<T5::Parameters, HCons<T6::Parameters, HCons<T7::Parameters, HCons<T8::Parameters, HNil>>>>>>>>>

type Strategy = (T0::Strategy, T1::Strategy, T2::Strategy, T3::Strategy, T4::Strategy, T5::Strategy, T6::Strategy, T7::Strategy, T8::Strategy)

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

impl<'a, T0: Arbitrary<'a>, T1: Arbitrary<'a>, T2: Arbitrary<'a>, T3: Arbitrary<'a>, T4: Arbitrary<'a>, T5: Arbitrary<'a>, T6: Arbitrary<'a>, T7: Arbitrary<'a>, T8: Arbitrary<'a>, T9: Arbitrary<'a>> Arbitrary<'a> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

type ValueTree = <Self::Strategy as Strategy>::Value

type Parameters = HCons<T0::Parameters, HCons<T1::Parameters, HCons<T2::Parameters, HCons<T3::Parameters, HCons<T4::Parameters, HCons<T5::Parameters, HCons<T6::Parameters, HCons<T7::Parameters, HCons<T8::Parameters, HCons<T9::Parameters, HNil>>>>>>>>>>

type Strategy = (T0::Strategy, T1::Strategy, T2::Strategy, T3::Strategy, T4::Strategy, T5::Strategy, T6::Strategy, T7::Strategy, T8::Strategy, T9::Strategy)

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

fn arbitrary() -> Self::Strategy

Implementors

• impl<'a> Arbitrary<'a> for Probability type ValueTree = <Self::Strategy as Strategy>::Value; type Parameters = (); type Strategy = SMap<Range<f64>, FromMapper<ValueFor<Range<f64>>, Self>>;
• impl<'a> Arbitrary<'a> for SizeBounds type ValueTree = <Self::Strategy as Strategy>::Value; type Parameters = (); type Strategy = FMapped<'a, Range<usize>, Self>;