Trait proptest_arbitrary::Arbitrary
[−]
[src]
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>
Required Methods
fn arbitrary_with(args: Self::Parameters) -> Self::Strategy
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
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Any
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for f32
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Any
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for f64
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Any
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for i8
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Any
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for i16
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Any
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for i32
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Any
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for i64
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Any
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for isize
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Any
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for u8
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Any
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for u16
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Any
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for u32
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Any
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for u64
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Any
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for usize
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Any
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for char
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = CharParam<'a>
type Strategy = CharStrategy<'a>
fn arbitrary_with(args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for EscapeDefault
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Box<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Copy> Arbitrary<'a> for Cell<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for RefCell<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for UnsafeCell<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for BorrowError
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for BorrowMutError
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for EscapeDebug
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for EscapeDefault
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for EscapeUnicode
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for ParseCharError
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for DecodeUtf16Error
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Reverse<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Ordering
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Vec<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Box<[A]>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Rc<[A]>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Arc<[A]>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for VecDeque<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for LinkedList<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Ord> Arbitrary<'a> for BTreeSet<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Ord> Arbitrary<'a> for BinaryHeap<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Hash + Eq> Arbitrary<'a> for HashSet<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Hash + Eq, B: Arbitrary<'a>> Arbitrary<'a> for HashMap<A, B>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A, B> Arbitrary<'a> for BTreeMap<A, B> where
A: Arbitrary<'static> + Ord,
B: Arbitrary<'static>,
StrategyFor<A>: 'static,
StrategyFor<B>: 'static,
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for IntoIter<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for IntoIter<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for IntoIter<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Ord> Arbitrary<'a> for IntoIter<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Ord> Arbitrary<'a> for IntoIter<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Hash + Eq> Arbitrary<'a> for IntoIter<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Hash + Eq, B: Arbitrary<'a>> Arbitrary<'a> for IntoIter<A, B>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A, B> Arbitrary<'a> for IntoIter<A, B> where
A: Arbitrary<'static> + Ord,
B: Arbitrary<'static>,
StrategyFor<A>: 'static,
StrategyFor<B>: 'static,
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Clone> Arbitrary<'a> for Bound<A> where
ParamsType<'a, A>: Clone,
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Args
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for ArgsOs
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Vars
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for VarsOs
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for JoinPathsError
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for VarError
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for CString
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for OsString
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Box<CStr>
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = SizeBounds
type Strategy = FMapped<'a, CString, Self>
fn arbitrary_with(a: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Box<OsStr>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for FromBytesWithNulError
[src]
impl<'a> Arbitrary<'a> for IntoStringError
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Error
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Just<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for DirBuilder
[src]
impl<'a, H: Default + Hasher> Arbitrary<'a> for BuildHasherDefault<H>
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Just<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for DefaultHasher
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for RandomState
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Read> Arbitrary<'a> for BufReader<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Write> Arbitrary<'a> for BufWriter<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Write> Arbitrary<'a> for LineWriter<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Read + Arbitrary<'a>, B: Read + Arbitrary<'a>> Arbitrary<'a> for Chain<A, B>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Cursor<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Empty
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Sink
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Stderr
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Stdin
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Stdout
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + BufRead> Arbitrary<'a> for Lines<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Repeat
[src]
impl<'a, A: BufRead + Arbitrary<'a>> Arbitrary<'a> for Split<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Read + Arbitrary<'a>> Arbitrary<'a> for Take<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for ErrorKind
[src]
impl<'a> Arbitrary<'a> for SeekFrom
[src]
impl<'a> Arbitrary<'a> for Error
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Once<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Clone> Arbitrary<'a> for Repeat<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Iterator<Item = &'a T>, T: 'a + Clone> Arbitrary<'a> for Cloned<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Iterator + Clone> Arbitrary<'a> for Cycle<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Iterator> Arbitrary<'a> for Enumerate<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Iterator> Arbitrary<'a> for Fuse<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Iterator<Item = T>, T: Debug> Arbitrary<'a> for Peekable<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + DoubleEndedIterator> Arbitrary<'a> for Rev<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A> Arbitrary<'a> for Empty<A>
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Just<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Iterator, B: Arbitrary<'a> + Iterator> Arbitrary<'a> for Zip<A, B>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, T, A: Arbitrary<'a> + Iterator<Item = T>, B: Arbitrary<'a> + Iterator<Item = T>> Arbitrary<'a> for Chain<A, B>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Iterator> Arbitrary<'a> for Skip<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a> + Iterator> Arbitrary<'a> for Take<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, T: ?Sized> Arbitrary<'a> for PhantomData<T>
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Just<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Discriminant<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for ManuallyDrop<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for AddrParseError
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Just<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Ipv4Addr
[src]
impl<'a> Arbitrary<'a> for Ipv6Addr
[src]
impl<'a> Arbitrary<'a> for SocketAddrV4
[src]
impl<'a> Arbitrary<'a> for SocketAddrV6
[src]
impl<'a> Arbitrary<'a> for IpAddr
[src]
impl<'a> Arbitrary<'a> for Shutdown
[src]
impl<'a> Arbitrary<'a> for SocketAddr
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for ParseFloatError
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Just<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for ParseIntError
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Just<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Wrapping<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for FpCategory
[src]
impl<'a> Arbitrary<'a> for RangeFull
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Just<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for RangeFrom<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for RangeTo<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: PartialOrd + Arbitrary<'a>> Arbitrary<'a> for Range<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Option<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for IntoIter<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for AssertUnwindSafe<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for StripPrefixError
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Just<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Rc<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>, B: Arbitrary<'a>> Arbitrary<'a> for Result<A, B>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for IntoIter<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for ParseBoolError
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Just<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Utf8Error
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for String
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = StringParam<'a>
type Strategy = &'a str
fn arbitrary_with(args: Self::Parameters) -> Self::Strategy
[src]
Safety
This implementation panics if the input is not a valid regex proptest can handle.
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Box<str>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Rc<str>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Arc<str>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for FromUtf16Error
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for FromUtf8Error
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Arc<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for Mutex<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for RwLock<A>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Barrier
[src]
impl<'a> Arbitrary<'a> for BarrierWaitResult
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Condvar
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for Once
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for WaitTimeoutResult
[src]
impl<'a> Arbitrary<'a> for AtomicBool
[src]
impl<'a> Arbitrary<'a> for AtomicIsize
[src]
impl<'a> Arbitrary<'a> for AtomicUsize
[src]
impl<'a> Arbitrary<'a> for Ordering
[src]
impl<'a> Arbitrary<'a> for RecvError
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Just<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, T: Arbitrary<'a>> Arbitrary<'a> for SendError<T>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for RecvTimeoutError
[src]
impl<'a> Arbitrary<'a> for TryRecvError
[src]
impl<'a, P: Clone + Default, T: Arbitrary<'a, Parameters = P>> Arbitrary<'a> for TrySendError<T>
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A> Arbitrary<'a> for (Sender<A>, Receiver<A>)
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Debug> Arbitrary<'a> for (Sender<A>, IntoIter<A>)
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = FnGenerator<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A> Arbitrary<'a> for (SyncSender<A>, Receiver<A>)
[src]
impl<'a, A: Debug> Arbitrary<'a> for (SyncSender<A>, IntoIter<A>)
[src]
impl<'a> Arbitrary<'a> for Builder
[src]
impl<'a> Arbitrary<'a> for Duration
[src]
impl<'a> Arbitrary<'a> for Instant
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Just<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for SystemTime
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Just<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 1]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 2]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 3]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 4]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 5]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 6]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 7]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 8]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 9]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 10]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 11]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 12]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 13]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 14]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 15]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 16]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 17]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 18]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 19]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 20]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 21]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 22]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 23]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 24]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 25]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 26]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 27]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 28]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 29]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 30]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 31]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, A: Arbitrary<'a>> Arbitrary<'a> for [A; 32]
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a> Arbitrary<'a> for ()
[src]
type ValueTree = <Self::Strategy as Strategy>::Value
type Parameters = ()
type Strategy = Just<Self>
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, T0: Arbitrary<'a>> Arbitrary<'a> for (T0,)
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, T0: Arbitrary<'a>, T1: Arbitrary<'a>> Arbitrary<'a> for (T0, T1)
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, T0: Arbitrary<'a>, T1: Arbitrary<'a>, T2: Arbitrary<'a>> Arbitrary<'a> for (T0, T1, T2)
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
impl<'a, T0: Arbitrary<'a>, T1: Arbitrary<'a>, T2: Arbitrary<'a>, T3: Arbitrary<'a>> Arbitrary<'a> for (T0, T1, T2, T3)
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
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)
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
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)
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
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)
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
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)
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
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)
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
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)
[src]
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
[src]
fn arbitrary() -> Self::Strategy
[src]
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>;