[−][src]Trait un_algebra::tests::config::prop::arbitrary::Arbitrary
Arbitrary determines a canonical Strategy
for the implementing type.
It provides the method arbitrary_with
which generates a Strategy
for
producing arbitrary values of the implementing type (Self
). In general,
these strategies will produce the entire set of values possible for the
type, up to some size limitation or constraints set by their parameters.
When this is not desired, strategies to produce the desired values can be
built by combining Strategy
s as described in the crate documentation.
This trait analogous to
Haskell QuickCheck's implementation of Arbitrary
.
In this interpretation of Arbitrary
, Strategy
is the equivalent of
the Gen
monad. Unlike in QuickCheck, Arbitrary
is not a core component;
types do not need to implement Arbitrary
unless one wants to use
any
or other free functions in this module.
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
The type of Strategy
used to generate values of type 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())
.
This method is defined in the trait for optimization for the default if you want to do that. It is a logic error to not preserve the semantics when overriding.
Implementations on Foreign Types
impl<A> Arbitrary for Result<A, !> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> Result<A, !>>
fn arbitrary_with(
args: <Result<A, !> as Arbitrary>::Parameters
) -> <Result<A, !> as Arbitrary>::Strategy
[src]
args: <Result<A, !> as Arbitrary>::Parameters
) -> <Result<A, !> as Arbitrary>::Strategy
impl Arbitrary for JoinPathsError
[src]
type Parameters = ()
type Strategy = LazyJust<JoinPathsError, fn() -> JoinPathsError>
fn arbitrary_with(
_args: <JoinPathsError as Arbitrary>::Parameters
) -> <JoinPathsError as Arbitrary>::Strategy
[src]
_args: <JoinPathsError as Arbitrary>::Parameters
) -> <JoinPathsError as Arbitrary>::Strategy
impl Arbitrary for u32
[src]
type Parameters = ()
type Strategy = Any
fn arbitrary_with(
_args: <u32 as Arbitrary>::Parameters
) -> <u32 as Arbitrary>::Strategy
[src]
_args: <u32 as Arbitrary>::Parameters
) -> <u32 as Arbitrary>::Strategy
impl<A> Arbitrary for Rc<[A]> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <Vec<A> as Arbitrary>::Parameters
type Strategy = MapInto<<Vec<A> as Arbitrary>::Strategy, Rc<[A]>>
fn arbitrary_with(
a: <Rc<[A]> as Arbitrary>::Parameters
) -> <Rc<[A]> as Arbitrary>::Strategy
[src]
a: <Rc<[A]> as Arbitrary>::Parameters
) -> <Rc<[A]> as Arbitrary>::Strategy
impl<A> Arbitrary for IntoIter<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <VecDeque<A> as Arbitrary>::Parameters
type Strategy = Map<<VecDeque<A> as Arbitrary>::Strategy, fn(VecDeque<A>) -> IntoIter<A>>
fn arbitrary_with(
args: <IntoIter<A> as Arbitrary>::Parameters
) -> <IntoIter<A> as Arbitrary>::Strategy
[src]
args: <IntoIter<A> as Arbitrary>::Parameters
) -> <IntoIter<A> as Arbitrary>::Strategy
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Arbitrary for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
T0: Arbitrary,
T1: Arbitrary,
T2: Arbitrary,
T3: Arbitrary,
T4: Arbitrary,
T5: Arbitrary,
T6: Arbitrary,
T7: Arbitrary,
T8: Arbitrary,
T9: Arbitrary,
[src]
T0: Arbitrary,
T1: Arbitrary,
T2: Arbitrary,
T3: Arbitrary,
T4: Arbitrary,
T5: Arbitrary,
T6: Arbitrary,
T7: Arbitrary,
T8: Arbitrary,
T9: Arbitrary,
type Parameters = (<T0 as Arbitrary>::Parameters, <T1 as Arbitrary>::Parameters, <T2 as Arbitrary>::Parameters, <T3 as Arbitrary>::Parameters, <T4 as Arbitrary>::Parameters, <T5 as Arbitrary>::Parameters, <T6 as Arbitrary>::Parameters, <T7 as Arbitrary>::Parameters, <T8 as Arbitrary>::Parameters, <T9 as Arbitrary>::Parameters)
type Strategy = (<T0 as Arbitrary>::Strategy, <T1 as Arbitrary>::Strategy, <T2 as Arbitrary>::Strategy, <T3 as Arbitrary>::Strategy, <T4 as Arbitrary>::Strategy, <T5 as Arbitrary>::Strategy, <T6 as Arbitrary>::Strategy, <T7 as Arbitrary>::Strategy, <T8 as Arbitrary>::Strategy, <T9 as Arbitrary>::Strategy)
fn arbitrary_with(
args: <(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) as Arbitrary>::Parameters
) -> <(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) as Arbitrary>::Strategy
[src]
args: <(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) as Arbitrary>::Parameters
) -> <(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) as Arbitrary>::Strategy
impl Arbitrary for Utf8Error
[src]
type Parameters = ()
type Strategy = Map<(<u16 as Arbitrary>::Strategy, LazyTupleUnion<((u32, Arc<Just<&'static [u8]>>), (u32, Arc<Just<&'static [u8]>>), (u32, Arc<Just<&'static [u8]>>), (u32, Arc<Just<&'static [u8]>>))>), fn(<(<u16 as Arbitrary>::Strategy, LazyTupleUnion<((u32, Arc<Just<&'static [u8]>>), (u32, Arc<Just<&'static [u8]>>), (u32, Arc<Just<&'static [u8]>>), (u32, Arc<Just<&'static [u8]>>))>) as Strategy>::Value) -> Utf8Error>
fn arbitrary_with(
_args: <Utf8Error as Arbitrary>::Parameters
) -> <Utf8Error as Arbitrary>::Strategy
[src]
_args: <Utf8Error as Arbitrary>::Parameters
) -> <Utf8Error as Arbitrary>::Strategy
impl<A> Arbitrary for Repeat<A> where
A: Arbitrary + Clone,
[src]
A: Arbitrary + Clone,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> Repeat<A>>
fn arbitrary_with(
args: <Repeat<A> as Arbitrary>::Parameters
) -> <Repeat<A> as Arbitrary>::Strategy
[src]
args: <Repeat<A> as Arbitrary>::Parameters
) -> <Repeat<A> as Arbitrary>::Strategy
impl Arbitrary for Duration
[src]
type Parameters = ()
type Strategy = Map<<(u64, u32) as Arbitrary>::Strategy, fn((u64, u32)) -> Duration>
fn arbitrary_with(
_args: <Duration as Arbitrary>::Parameters
) -> <Duration as Arbitrary>::Strategy
[src]
_args: <Duration as Arbitrary>::Parameters
) -> <Duration as Arbitrary>::Strategy
impl<A> Arbitrary for BufReader<A> where
A: Arbitrary + Read,
[src]
A: Arbitrary + Read,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<(A, Option<u16>) as Arbitrary>::Strategy, fn((A, Option<u16>)) -> BufReader<A>>
fn arbitrary_with(
args: <BufReader<A> as Arbitrary>::Parameters
) -> <BufReader<A> as Arbitrary>::Strategy
[src]
args: <BufReader<A> as Arbitrary>::Parameters
) -> <BufReader<A> as Arbitrary>::Strategy
impl Arbitrary for TryRecvError
[src]
type Parameters = ()
type Strategy = LazyTupleUnion<((u32, Arc<Just<TryRecvError>>), (u32, Arc<Just<TryRecvError>>))>
fn arbitrary_with(
_args: <TryRecvError as Arbitrary>::Parameters
) -> <TryRecvError as Arbitrary>::Strategy
[src]
_args: <TryRecvError as Arbitrary>::Parameters
) -> <TryRecvError as Arbitrary>::Strategy
impl<A> Arbitrary for Box<[A]> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <Vec<A> as Arbitrary>::Parameters
type Strategy = MapInto<<Vec<A> as Arbitrary>::Strategy, Box<[A]>>
fn arbitrary_with(
a: <Box<[A]> as Arbitrary>::Parameters
) -> <Box<[A]> as Arbitrary>::Strategy
[src]
a: <Box<[A]> as Arbitrary>::Parameters
) -> <Box<[A]> as Arbitrary>::Strategy
impl<A> Arbitrary for Rc<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = MapInto<<A as Arbitrary>::Strategy, Rc<A>>
fn arbitrary_with(
args: <Rc<A> as Arbitrary>::Parameters
) -> <Rc<A> as Arbitrary>::Strategy
[src]
args: <Rc<A> as Arbitrary>::Parameters
) -> <Rc<A> as Arbitrary>::Strategy
impl<A> Arbitrary for Skip<A> where
A: Arbitrary + Iterator,
[src]
A: Arbitrary + Iterator,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<(A, usize) as Arbitrary>::Strategy, fn((A, usize)) -> Skip<A>>
fn arbitrary_with(
a: <Skip<A> as Arbitrary>::Parameters
) -> <Skip<A> as Arbitrary>::Strategy
[src]
a: <Skip<A> as Arbitrary>::Parameters
) -> <Skip<A> as Arbitrary>::Strategy
impl Arbitrary for DefaultHasher
[src]
type Parameters = ()
type Strategy = LazyJust<DefaultHasher, fn() -> DefaultHasher>
fn arbitrary_with(
_args: <DefaultHasher as Arbitrary>::Parameters
) -> <DefaultHasher as Arbitrary>::Strategy
[src]
_args: <DefaultHasher as Arbitrary>::Parameters
) -> <DefaultHasher as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 23] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 23]>
fn arbitrary_with(
args: <[A; 23] as Arbitrary>::Parameters
) -> <[A; 23] as Arbitrary>::Strategy
[src]
args: <[A; 23] as Arbitrary>::Parameters
) -> <[A; 23] as Arbitrary>::Strategy
impl<A, B> Arbitrary for Chain<A, B> where
A: Arbitrary + Read,
B: Arbitrary + Read,
[src]
A: Arbitrary + Read,
B: Arbitrary + Read,
type Parameters = (<A as Arbitrary>::Parameters, <B as Arbitrary>::Parameters)
type Strategy = Map<<(A, B) as Arbitrary>::Strategy, fn((A, B)) -> Chain<A, B>>
fn arbitrary_with(
args: <Chain<A, B> as Arbitrary>::Parameters
) -> <Chain<A, B> as Arbitrary>::Strategy
[src]
args: <Chain<A, B> as Arbitrary>::Parameters
) -> <Chain<A, B> as Arbitrary>::Strategy
impl<T> Arbitrary for PhantomData<T> where
T: ?Sized,
[src]
T: ?Sized,
type Parameters = ()
type Strategy = Just<PhantomData<T>>
fn arbitrary_with(
_args: <PhantomData<T> as Arbitrary>::Parameters
) -> <PhantomData<T> as Arbitrary>::Strategy
[src]
_args: <PhantomData<T> as Arbitrary>::Parameters
) -> <PhantomData<T> as Arbitrary>::Strategy
impl Arbitrary for i32
[src]
type Parameters = ()
type Strategy = Any
fn arbitrary_with(
_args: <i32 as Arbitrary>::Parameters
) -> <i32 as Arbitrary>::Strategy
[src]
_args: <i32 as Arbitrary>::Parameters
) -> <i32 as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 6] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 6]>
fn arbitrary_with(
args: <[A; 6] as Arbitrary>::Parameters
) -> <[A; 6] as Arbitrary>::Strategy
[src]
args: <[A; 6] as Arbitrary>::Parameters
) -> <[A; 6] as Arbitrary>::Strategy
impl<'a, T, A> Arbitrary for Cloned<A> where
A: Arbitrary + Iterator<Item = &'a T>,
T: 'a + Clone,
[src]
A: Arbitrary + Iterator<Item = &'a T>,
T: 'a + Clone,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> Cloned<A>>
fn arbitrary_with(
args: <Cloned<A> as Arbitrary>::Parameters
) -> <Cloned<A> as Arbitrary>::Strategy
[src]
args: <Cloned<A> as Arbitrary>::Parameters
) -> <Cloned<A> as Arbitrary>::Strategy
impl<T, A, B> Arbitrary for Chain<A, B> where
A: Arbitrary + Iterator<Item = T>,
B: Arbitrary + Iterator<Item = T>,
[src]
A: Arbitrary + Iterator<Item = T>,
B: Arbitrary + Iterator<Item = T>,
type Parameters = (<A as Arbitrary>::Parameters, <B as Arbitrary>::Parameters)
type Strategy = Map<<(A, B) as Arbitrary>::Strategy, fn((A, B)) -> Chain<A, B>>
fn arbitrary_with(
args: <Chain<A, B> as Arbitrary>::Parameters
) -> <Chain<A, B> as Arbitrary>::Strategy
[src]
args: <Chain<A, B> as Arbitrary>::Parameters
) -> <Chain<A, B> as Arbitrary>::Strategy
impl Arbitrary for u8
[src]
type Parameters = ()
type Strategy = Any
fn arbitrary_with(
_args: <u8 as Arbitrary>::Parameters
) -> <u8 as Arbitrary>::Strategy
[src]
_args: <u8 as Arbitrary>::Parameters
) -> <u8 as Arbitrary>::Strategy
impl<A> Arbitrary for Enumerate<A> where
A: Arbitrary + Iterator,
[src]
A: Arbitrary + Iterator,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> Enumerate<A>>
fn arbitrary_with(
args: <Enumerate<A> as Arbitrary>::Parameters
) -> <Enumerate<A> as Arbitrary>::Strategy
[src]
args: <Enumerate<A> as Arbitrary>::Parameters
) -> <Enumerate<A> as Arbitrary>::Strategy
impl<A> Arbitrary for IntoIter<A> where
A: Arbitrary + Eq + Hash,
[src]
A: Arbitrary + Eq + Hash,
type Parameters = <HashSet<A, RandomState> as Arbitrary>::Parameters
type Strategy = Map<<HashSet<A, RandomState> as Arbitrary>::Strategy, fn(HashSet<A, RandomState>) -> IntoIter<A>>
fn arbitrary_with(
args: <IntoIter<A> as Arbitrary>::Parameters
) -> <IntoIter<A> as Arbitrary>::Strategy
[src]
args: <IntoIter<A> as Arbitrary>::Parameters
) -> <IntoIter<A> as Arbitrary>::Strategy
impl Arbitrary for Error
[src]
type Parameters = ()
type Strategy = Map<<(ErrorKind, Option<String>) as Arbitrary>::Strategy, fn((ErrorKind, Option<String>)) -> Error>
fn arbitrary_with(
_args: <Error as Arbitrary>::Parameters
) -> <Error as Arbitrary>::Strategy
[src]
_args: <Error as Arbitrary>::Parameters
) -> <Error as Arbitrary>::Strategy
impl<A> Arbitrary for Take<A> where
A: Arbitrary + Read,
[src]
A: Arbitrary + Read,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<(A, u64) as Arbitrary>::Strategy, fn((A, u64)) -> Take<A>>
fn arbitrary_with(
args: <Take<A> as Arbitrary>::Parameters
) -> <Take<A> as Arbitrary>::Strategy
[src]
args: <Take<A> as Arbitrary>::Parameters
) -> <Take<A> as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 2] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 2]>
fn arbitrary_with(
args: <[A; 2] as Arbitrary>::Parameters
) -> <[A; 2] as Arbitrary>::Strategy
[src]
args: <[A; 2] as Arbitrary>::Parameters
) -> <[A; 2] as Arbitrary>::Strategy
impl Arbitrary for ()
[src]
type Parameters = ()
type Strategy = Just<()>
fn arbitrary_with(
_args: <() as Arbitrary>::Parameters
) -> <() as Arbitrary>::Strategy
[src]
_args: <() as Arbitrary>::Parameters
) -> <() as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 27] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 27]>
fn arbitrary_with(
args: <[A; 27] as Arbitrary>::Parameters
) -> <[A; 27] as Arbitrary>::Strategy
[src]
args: <[A; 27] as Arbitrary>::Parameters
) -> <[A; 27] as Arbitrary>::Strategy
impl<T0> Arbitrary for (T0,) where
T0: Arbitrary,
[src]
T0: Arbitrary,
type Parameters = (<T0 as Arbitrary>::Parameters,)
type Strategy = (<T0 as Arbitrary>::Strategy,)
fn arbitrary_with(
args: <(T0,) as Arbitrary>::Parameters
) -> <(T0,) as Arbitrary>::Strategy
[src]
args: <(T0,) as Arbitrary>::Parameters
) -> <(T0,) as Arbitrary>::Strategy
impl Arbitrary for Instant
[src]
type Parameters = ()
type Strategy = Just<Instant>
fn arbitrary_with(
_args: <Instant as Arbitrary>::Parameters
) -> <Instant as Arbitrary>::Strategy
[src]
_args: <Instant as Arbitrary>::Parameters
) -> <Instant as Arbitrary>::Strategy
impl Arbitrary for u64
[src]
type Parameters = ()
type Strategy = Any
fn arbitrary_with(
_args: <u64 as Arbitrary>::Parameters
) -> <u64 as Arbitrary>::Strategy
[src]
_args: <u64 as Arbitrary>::Parameters
) -> <u64 as Arbitrary>::Strategy
impl<A> Arbitrary for (SyncSender<A>, IntoIter<A>) where
A: Debug,
[src]
A: Debug,
type Parameters = ()
type Strategy = Map<<u16 as Arbitrary>::Strategy, fn(u16) -> (SyncSender<A>, IntoIter<A>)>
fn arbitrary_with(
_args: <(SyncSender<A>, IntoIter<A>) as Arbitrary>::Parameters
) -> <(SyncSender<A>, IntoIter<A>) as Arbitrary>::Strategy
[src]
_args: <(SyncSender<A>, IntoIter<A>) as Arbitrary>::Parameters
) -> <(SyncSender<A>, IntoIter<A>) as Arbitrary>::Strategy
impl Arbitrary for VarError
[src]
type Parameters = ()
type Strategy = LazyTupleUnion<((u32, Arc<Just<VarError>>), (u32, Arc<Map<BoxedStrategy<OsString>, fn(<BoxedStrategy<OsString> as Strategy>::Value) -> VarError>>))>
fn arbitrary_with(
_args: <VarError as Arbitrary>::Parameters
) -> <VarError as Arbitrary>::Strategy
[src]
_args: <VarError as Arbitrary>::Parameters
) -> <VarError as Arbitrary>::Strategy
impl<A, B> Arbitrary for Zip<A, B> where
A: Arbitrary + Iterator,
B: Arbitrary + Iterator,
[src]
A: Arbitrary + Iterator,
B: Arbitrary + Iterator,
type Parameters = (<A as Arbitrary>::Parameters, <B as Arbitrary>::Parameters)
type Strategy = Map<<(A, B) as Arbitrary>::Strategy, fn((A, B)) -> Zip<A, B>>
fn arbitrary_with(
args: <Zip<A, B> as Arbitrary>::Parameters
) -> <Zip<A, B> as Arbitrary>::Strategy
[src]
args: <Zip<A, B> as Arbitrary>::Parameters
) -> <Zip<A, B> as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 1] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 1]>
fn arbitrary_with(
args: <[A; 1] as Arbitrary>::Parameters
) -> <[A; 1] as Arbitrary>::Strategy
[src]
args: <[A; 1] as Arbitrary>::Parameters
) -> <[A; 1] as Arbitrary>::Strategy
impl<A> Arbitrary for IntoIter<A> where
A: Arbitrary + Ord,
[src]
A: Arbitrary + Ord,
type Parameters = <BinaryHeap<A> as Arbitrary>::Parameters
type Strategy = Map<<BinaryHeap<A> as Arbitrary>::Strategy, fn(BinaryHeap<A>) -> IntoIter<A>>
fn arbitrary_with(
args: <IntoIter<A> as Arbitrary>::Parameters
) -> <IntoIter<A> as Arbitrary>::Strategy
[src]
args: <IntoIter<A> as Arbitrary>::Parameters
) -> <IntoIter<A> as Arbitrary>::Strategy
impl<A> Arbitrary for IntoIter<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <LinkedList<A> as Arbitrary>::Parameters
type Strategy = Map<<LinkedList<A> as Arbitrary>::Strategy, fn(LinkedList<A>) -> IntoIter<A>>
fn arbitrary_with(
args: <IntoIter<A> as Arbitrary>::Parameters
) -> <IntoIter<A> as Arbitrary>::Strategy
[src]
args: <IntoIter<A> as Arbitrary>::Parameters
) -> <IntoIter<A> as Arbitrary>::Strategy
impl Arbitrary for Repeat
[src]
type Parameters = ()
type Strategy = Map<<u8 as Arbitrary>::Strategy, fn(u8) -> Repeat>
fn arbitrary_with(
_args: <Repeat as Arbitrary>::Parameters
) -> <Repeat as Arbitrary>::Strategy
[src]
_args: <Repeat as Arbitrary>::Parameters
) -> <Repeat as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 9] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 9]>
fn arbitrary_with(
args: <[A; 9] as Arbitrary>::Parameters
) -> <[A; 9] as Arbitrary>::Strategy
[src]
args: <[A; 9] as Arbitrary>::Parameters
) -> <[A; 9] as Arbitrary>::Strategy
impl Arbitrary for Stdin
[src]
type Parameters = ()
type Strategy = LazyJust<Stdin, fn() -> Stdin>
fn arbitrary_with(
_args: <Stdin as Arbitrary>::Parameters
) -> <Stdin as Arbitrary>::Strategy
[src]
_args: <Stdin as Arbitrary>::Parameters
) -> <Stdin as Arbitrary>::Strategy
impl Arbitrary for DirBuilder
[src]
type Parameters = ()
type Strategy = Map<<bool as Arbitrary>::Strategy, fn(bool) -> DirBuilder>
fn arbitrary_with(
_args: <DirBuilder as Arbitrary>::Parameters
) -> <DirBuilder as Arbitrary>::Strategy
[src]
_args: <DirBuilder as Arbitrary>::Parameters
) -> <DirBuilder as Arbitrary>::Strategy
impl Arbitrary for Vars
[src]
type Parameters = ()
type Strategy = LazyJust<Vars, fn() -> Vars>
fn arbitrary_with(
_args: <Vars as Arbitrary>::Parameters
) -> <Vars as Arbitrary>::Strategy
[src]
_args: <Vars as Arbitrary>::Parameters
) -> <Vars as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 30] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 30]>
fn arbitrary_with(
args: <[A; 30] as Arbitrary>::Parameters
) -> <[A; 30] as Arbitrary>::Strategy
[src]
args: <[A; 30] as Arbitrary>::Parameters
) -> <[A; 30] as Arbitrary>::Strategy
impl<A> Arbitrary for Result<!, A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> Result<!, A>>
fn arbitrary_with(
args: <Result<!, A> as Arbitrary>::Parameters
) -> <Result<!, A> as Arbitrary>::Strategy
[src]
args: <Result<!, A> as Arbitrary>::Parameters
) -> <Result<!, A> as Arbitrary>::Strategy
impl Arbitrary for AddrParseError
[src]
type Parameters = ()
type Strategy = Just<AddrParseError>
fn arbitrary_with(
_args: <AddrParseError as Arbitrary>::Parameters
) -> <AddrParseError as Arbitrary>::Strategy
[src]
_args: <AddrParseError as Arbitrary>::Parameters
) -> <AddrParseError as Arbitrary>::Strategy
impl Arbitrary for i128
[src]
type Parameters = ()
type Strategy = Any
fn arbitrary_with(
_args: <i128 as Arbitrary>::Parameters
) -> <i128 as Arbitrary>::Strategy
[src]
_args: <i128 as Arbitrary>::Parameters
) -> <i128 as Arbitrary>::Strategy
impl<T0, T1, T2, T3, T4, T5, T6> Arbitrary for (T0, T1, T2, T3, T4, T5, T6) where
T0: Arbitrary,
T1: Arbitrary,
T2: Arbitrary,
T3: Arbitrary,
T4: Arbitrary,
T5: Arbitrary,
T6: Arbitrary,
[src]
T0: Arbitrary,
T1: Arbitrary,
T2: Arbitrary,
T3: Arbitrary,
T4: Arbitrary,
T5: Arbitrary,
T6: Arbitrary,
type Parameters = (<T0 as Arbitrary>::Parameters, <T1 as Arbitrary>::Parameters, <T2 as Arbitrary>::Parameters, <T3 as Arbitrary>::Parameters, <T4 as Arbitrary>::Parameters, <T5 as Arbitrary>::Parameters, <T6 as Arbitrary>::Parameters)
type Strategy = (<T0 as Arbitrary>::Strategy, <T1 as Arbitrary>::Strategy, <T2 as Arbitrary>::Strategy, <T3 as Arbitrary>::Strategy, <T4 as Arbitrary>::Strategy, <T5 as Arbitrary>::Strategy, <T6 as Arbitrary>::Strategy)
fn arbitrary_with(
args: <(T0, T1, T2, T3, T4, T5, T6) as Arbitrary>::Parameters
) -> <(T0, T1, T2, T3, T4, T5, T6) as Arbitrary>::Strategy
[src]
args: <(T0, T1, T2, T3, T4, T5, T6) as Arbitrary>::Parameters
) -> <(T0, T1, T2, T3, T4, T5, T6) as Arbitrary>::Strategy
impl<A> Arbitrary for Cursor<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> Cursor<A>>
fn arbitrary_with(
args: <Cursor<A> as Arbitrary>::Parameters
) -> <Cursor<A> as Arbitrary>::Strategy
[src]
args: <Cursor<A> as Arbitrary>::Parameters
) -> <Cursor<A> as Arbitrary>::Strategy
impl<A> Arbitrary for (Sender<A>, IntoIter<A>) where
A: Debug,
[src]
A: Debug,
type Parameters = ()
type Strategy = LazyJust<(Sender<A>, IntoIter<A>), fn() -> (Sender<A>, IntoIter<A>)>
fn arbitrary_with(
_args: <(Sender<A>, IntoIter<A>) as Arbitrary>::Parameters
) -> <(Sender<A>, IntoIter<A>) as Arbitrary>::Strategy
[src]
_args: <(Sender<A>, IntoIter<A>) as Arbitrary>::Parameters
) -> <(Sender<A>, IntoIter<A>) as Arbitrary>::Strategy
impl<A> Arbitrary for IntoIter<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <Result<A, ()> as Arbitrary>::Parameters
type Strategy = Map<<Result<A, ()> as Arbitrary>::Strategy, fn(Result<A, ()>) -> IntoIter<A>>
fn arbitrary_with(
args: <IntoIter<A> as Arbitrary>::Parameters
) -> <IntoIter<A> as Arbitrary>::Strategy
[src]
args: <IntoIter<A> as Arbitrary>::Parameters
) -> <IntoIter<A> as Arbitrary>::Strategy
impl Arbitrary for IntoStringError
[src]
type Parameters = ()
type Strategy = Map<BoxedStrategy<Vec<u8>>, fn(<BoxedStrategy<Vec<u8>> as Strategy>::Value) -> IntoStringError>
fn arbitrary_with(
_args: <IntoStringError as Arbitrary>::Parameters
) -> <IntoStringError as Arbitrary>::Strategy
[src]
_args: <IntoStringError as Arbitrary>::Parameters
) -> <IntoStringError as Arbitrary>::Strategy
impl Arbitrary for isize
[src]
type Parameters = ()
type Strategy = Any
fn arbitrary_with(
_args: <isize as Arbitrary>::Parameters
) -> <isize as Arbitrary>::Strategy
[src]
_args: <isize as Arbitrary>::Parameters
) -> <isize as Arbitrary>::Strategy
impl<A> Arbitrary for Arc<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = MapInto<<A as Arbitrary>::Strategy, Arc<A>>
fn arbitrary_with(
args: <Arc<A> as Arbitrary>::Parameters
) -> <Arc<A> as Arbitrary>::Strategy
[src]
args: <Arc<A> as Arbitrary>::Parameters
) -> <Arc<A> as Arbitrary>::Strategy
impl<A> Arbitrary for LinkedList<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = (SizeRange, <A as Arbitrary>::Parameters)
type Strategy = LinkedListStrategy<<A as Arbitrary>::Strategy>
fn arbitrary_with(
args: <LinkedList<A> as Arbitrary>::Parameters
) -> <LinkedList<A> as Arbitrary>::Strategy
[src]
args: <LinkedList<A> as Arbitrary>::Parameters
) -> <LinkedList<A> as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 31] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 31]>
fn arbitrary_with(
args: <[A; 31] as Arbitrary>::Parameters
) -> <[A; 31] as Arbitrary>::Strategy
[src]
args: <[A; 31] as Arbitrary>::Parameters
) -> <[A; 31] as Arbitrary>::Strategy
impl<A> Arbitrary for IntoIter<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <Vec<A> as Arbitrary>::Parameters
type Strategy = Map<<Vec<A> as Arbitrary>::Strategy, fn(Vec<A>) -> IntoIter<A>>
fn arbitrary_with(
args: <IntoIter<A> as Arbitrary>::Parameters
) -> <IntoIter<A> as Arbitrary>::Strategy
[src]
args: <IntoIter<A> as Arbitrary>::Parameters
) -> <IntoIter<A> as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 29] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 29]>
fn arbitrary_with(
args: <[A; 29] as Arbitrary>::Parameters
) -> <[A; 29] as Arbitrary>::Strategy
[src]
args: <[A; 29] as Arbitrary>::Parameters
) -> <[A; 29] as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 4] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 4]>
fn arbitrary_with(
args: <[A; 4] as Arbitrary>::Parameters
) -> <[A; 4] as Arbitrary>::Strategy
[src]
args: <[A; 4] as Arbitrary>::Parameters
) -> <[A; 4] as Arbitrary>::Strategy
impl<A> Arbitrary for LineWriter<A> where
A: Arbitrary + Write,
[src]
A: Arbitrary + Write,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<(A, Option<u16>) as Arbitrary>::Strategy, fn((A, Option<u16>)) -> LineWriter<A>>
fn arbitrary_with(
args: <LineWriter<A> as Arbitrary>::Parameters
) -> <LineWriter<A> as Arbitrary>::Strategy
[src]
args: <LineWriter<A> as Arbitrary>::Parameters
) -> <LineWriter<A> as Arbitrary>::Strategy
impl<A> Arbitrary for Reverse<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> Reverse<A>>
fn arbitrary_with(
args: <Reverse<A> as Arbitrary>::Parameters
) -> <Reverse<A> as Arbitrary>::Strategy
[src]
args: <Reverse<A> as Arbitrary>::Parameters
) -> <Reverse<A> as Arbitrary>::Strategy
impl Arbitrary for f32
[src]
type Parameters = ()
type Strategy = Any
fn arbitrary_with(
_args: <f32 as Arbitrary>::Parameters
) -> <f32 as Arbitrary>::Strategy
[src]
_args: <f32 as Arbitrary>::Parameters
) -> <f32 as Arbitrary>::Strategy
impl Arbitrary for Box<CStr>
[src]
type Parameters = SizeRange
type Strategy = MapInto<<CString as Arbitrary>::Strategy, Box<CStr>>
fn arbitrary_with(
a: <Box<CStr> as Arbitrary>::Parameters
) -> <Box<CStr> as Arbitrary>::Strategy
[src]
a: <Box<CStr> as Arbitrary>::Parameters
) -> <Box<CStr> as Arbitrary>::Strategy
impl Arbitrary for Ordering
[src]
type Parameters = ()
type Strategy = LazyTupleUnion<((u32, Arc<Just<Ordering>>), (u32, Arc<Just<Ordering>>), (u32, Arc<Just<Ordering>>), (u32, Arc<Just<Ordering>>), (u32, Arc<Just<Ordering>>))>
fn arbitrary_with(
_args: <Ordering as Arbitrary>::Parameters
) -> <Ordering as Arbitrary>::Strategy
[src]
_args: <Ordering as Arbitrary>::Parameters
) -> <Ordering as Arbitrary>::Strategy
impl<A, T> Arbitrary for Peekable<A> where
A: Arbitrary + Iterator<Item = T>,
T: Debug,
[src]
A: Arbitrary + Iterator<Item = T>,
T: Debug,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> Peekable<A>>
fn arbitrary_with(
args: <Peekable<A> as Arbitrary>::Parameters
) -> <Peekable<A> as Arbitrary>::Strategy
[src]
args: <Peekable<A> as Arbitrary>::Parameters
) -> <Peekable<A> as Arbitrary>::Strategy
impl<A, B> Arbitrary for BTreeMap<A, B> where
A: Arbitrary + Ord,
B: Arbitrary,
[src]
A: Arbitrary + Ord,
B: Arbitrary,
type Parameters = (SizeRange, <A as Arbitrary>::Parameters, <B as Arbitrary>::Parameters)
type Strategy = BTreeMapStrategy<<A as Arbitrary>::Strategy, <B as Arbitrary>::Strategy>
fn arbitrary_with(
args: <BTreeMap<A, B> as Arbitrary>::Parameters
) -> <BTreeMap<A, B> as Arbitrary>::Strategy
[src]
args: <BTreeMap<A, B> as Arbitrary>::Parameters
) -> <BTreeMap<A, B> as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 10] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 10]>
fn arbitrary_with(
args: <[A; 10] as Arbitrary>::Parameters
) -> <[A; 10] as Arbitrary>::Strategy
[src]
args: <[A; 10] as Arbitrary>::Parameters
) -> <[A; 10] as Arbitrary>::Strategy
impl Arbitrary for ArgsOs
[src]
type Parameters = ()
type Strategy = LazyJust<ArgsOs, fn() -> ArgsOs>
fn arbitrary_with(
_args: <ArgsOs as Arbitrary>::Parameters
) -> <ArgsOs as Arbitrary>::Strategy
[src]
_args: <ArgsOs as Arbitrary>::Parameters
) -> <ArgsOs as Arbitrary>::Strategy
impl Arbitrary for WaitTimeoutResult
[src]
type Parameters = ()
type Strategy = LazyTupleUnion<((u32, Arc<Just<WaitTimeoutResult>>), (u32, Arc<Just<WaitTimeoutResult>>))>
fn arbitrary_with(
_args: <WaitTimeoutResult as Arbitrary>::Parameters
) -> <WaitTimeoutResult as Arbitrary>::Strategy
[src]
_args: <WaitTimeoutResult as Arbitrary>::Parameters
) -> <WaitTimeoutResult as Arbitrary>::Strategy
impl<T0, T1, T2> Arbitrary for (T0, T1, T2) where
T0: Arbitrary,
T1: Arbitrary,
T2: Arbitrary,
[src]
T0: Arbitrary,
T1: Arbitrary,
T2: Arbitrary,
type Parameters = (<T0 as Arbitrary>::Parameters, <T1 as Arbitrary>::Parameters, <T2 as Arbitrary>::Parameters)
type Strategy = (<T0 as Arbitrary>::Strategy, <T1 as Arbitrary>::Strategy, <T2 as Arbitrary>::Strategy)
fn arbitrary_with(
args: <(T0, T1, T2) as Arbitrary>::Parameters
) -> <(T0, T1, T2) as Arbitrary>::Strategy
[src]
args: <(T0, T1, T2) as Arbitrary>::Parameters
) -> <(T0, T1, T2) as Arbitrary>::Strategy
impl<A, B> Arbitrary for IntoIter<A, B> where
A: Arbitrary + Ord,
B: Arbitrary,
[src]
A: Arbitrary + Ord,
B: Arbitrary,
type Parameters = <BTreeMap<A, B> as Arbitrary>::Parameters
type Strategy = Map<<BTreeMap<A, B> as Arbitrary>::Strategy, fn(BTreeMap<A, B>) -> IntoIter<A, B>>
fn arbitrary_with(
args: <IntoIter<A, B> as Arbitrary>::Parameters
) -> <IntoIter<A, B> as Arbitrary>::Strategy
[src]
args: <IntoIter<A, B> as Arbitrary>::Parameters
) -> <IntoIter<A, B> as Arbitrary>::Strategy
impl<T0, T1> Arbitrary for (T0, T1) where
T0: Arbitrary,
T1: Arbitrary,
[src]
T0: Arbitrary,
T1: Arbitrary,
type Parameters = (<T0 as Arbitrary>::Parameters, <T1 as Arbitrary>::Parameters)
type Strategy = (<T0 as Arbitrary>::Strategy, <T1 as Arbitrary>::Strategy)
fn arbitrary_with(
args: <(T0, T1) as Arbitrary>::Parameters
) -> <(T0, T1) as Arbitrary>::Strategy
[src]
args: <(T0, T1) as Arbitrary>::Parameters
) -> <(T0, T1) as Arbitrary>::Strategy
impl<H> Arbitrary for BuildHasherDefault<H> where
H: Default + Hasher,
[src]
H: Default + Hasher,
type Parameters = ()
type Strategy = Just<BuildHasherDefault<H>>
fn arbitrary_with(
_args: <BuildHasherDefault<H> as Arbitrary>::Parameters
) -> <BuildHasherDefault<H> as Arbitrary>::Strategy
[src]
_args: <BuildHasherDefault<H> as Arbitrary>::Parameters
) -> <BuildHasherDefault<H> as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 14] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 14]>
fn arbitrary_with(
args: <[A; 14] as Arbitrary>::Parameters
) -> <[A; 14] as Arbitrary>::Strategy
[src]
args: <[A; 14] as Arbitrary>::Parameters
) -> <[A; 14] as Arbitrary>::Strategy
impl<A> Arbitrary for HashSet<A, RandomState> where
A: Arbitrary + Eq + Hash,
[src]
A: Arbitrary + Eq + Hash,
type Parameters = (SizeRange, <A as Arbitrary>::Parameters)
type Strategy = HashSetStrategy<<A as Arbitrary>::Strategy>
fn arbitrary_with(
args: <HashSet<A, RandomState> as Arbitrary>::Parameters
) -> <HashSet<A, RandomState> as Arbitrary>::Strategy
[src]
args: <HashSet<A, RandomState> as Arbitrary>::Parameters
) -> <HashSet<A, RandomState> as Arbitrary>::Strategy
impl<A> Arbitrary for Cycle<A> where
A: Arbitrary + Clone + Iterator,
[src]
A: Arbitrary + Clone + Iterator,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> Cycle<A>>
fn arbitrary_with(
args: <Cycle<A> as Arbitrary>::Parameters
) -> <Cycle<A> as Arbitrary>::Strategy
[src]
args: <Cycle<A> as Arbitrary>::Parameters
) -> <Cycle<A> as Arbitrary>::Strategy
impl<A> Arbitrary for Once<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> Once<A>>
fn arbitrary_with(
args: <Once<A> as Arbitrary>::Parameters
) -> <Once<A> as Arbitrary>::Strategy
[src]
args: <Once<A> as Arbitrary>::Parameters
) -> <Once<A> as Arbitrary>::Strategy
impl<A> Arbitrary for Fuse<A> where
A: Arbitrary + Iterator,
[src]
A: Arbitrary + Iterator,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> Fuse<A>>
fn arbitrary_with(
args: <Fuse<A> as Arbitrary>::Parameters
) -> <Fuse<A> as Arbitrary>::Strategy
[src]
args: <Fuse<A> as Arbitrary>::Parameters
) -> <Fuse<A> as Arbitrary>::Strategy
impl<A, B> Arbitrary for HashMap<A, B, RandomState> where
A: Arbitrary + Eq + Hash,
B: Arbitrary,
[src]
A: Arbitrary + Eq + Hash,
B: Arbitrary,
type Parameters = (SizeRange, <A as Arbitrary>::Parameters, <B as Arbitrary>::Parameters)
type Strategy = HashMapStrategy<<A as Arbitrary>::Strategy, <B as Arbitrary>::Strategy>
fn arbitrary_with(
args: <HashMap<A, B, RandomState> as Arbitrary>::Parameters
) -> <HashMap<A, B, RandomState> as Arbitrary>::Strategy
[src]
args: <HashMap<A, B, RandomState> as Arbitrary>::Parameters
) -> <HashMap<A, B, RandomState> as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 26] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 26]>
fn arbitrary_with(
args: <[A; 26] as Arbitrary>::Parameters
) -> <[A; 26] as Arbitrary>::Strategy
[src]
args: <[A; 26] as Arbitrary>::Parameters
) -> <[A; 26] as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 8] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 8]>
fn arbitrary_with(
args: <[A; 8] as Arbitrary>::Parameters
) -> <[A; 8] as Arbitrary>::Strategy
[src]
args: <[A; 8] as Arbitrary>::Parameters
) -> <[A; 8] as Arbitrary>::Strategy
impl<P, T> Arbitrary for TrySendError<T> where
P: Clone + Default,
T: Arbitrary<Parameters = P>,
[src]
P: Clone + Default,
T: Arbitrary<Parameters = P>,
type Parameters = P
type Strategy = LazyTupleUnion<((u32, Arc<Map<<T as Arbitrary>::Strategy, fn(T) -> TrySendError<T>>>), (u32, Arc<Map<<T as Arbitrary>::Strategy, fn(T) -> TrySendError<T>>>))>
fn arbitrary_with(
args: <TrySendError<T> as Arbitrary>::Parameters
) -> <TrySendError<T> as Arbitrary>::Strategy
[src]
args: <TrySendError<T> as Arbitrary>::Parameters
) -> <TrySendError<T> as Arbitrary>::Strategy
impl Arbitrary for Box<OsStr>
[src]
type Parameters = <String as Arbitrary>::Parameters
type Strategy = MapInto<<OsString as Arbitrary>::Strategy, Box<OsStr>>
fn arbitrary_with(
a: <Box<OsStr> as Arbitrary>::Parameters
) -> <Box<OsStr> as Arbitrary>::Strategy
[src]
a: <Box<OsStr> as Arbitrary>::Parameters
) -> <Box<OsStr> as Arbitrary>::Strategy
impl<A> Arbitrary for Discriminant<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> Discriminant<A>>
fn arbitrary_with(
args: <Discriminant<A> as Arbitrary>::Parameters
) -> <Discriminant<A> as Arbitrary>::Strategy
[src]
args: <Discriminant<A> as Arbitrary>::Parameters
) -> <Discriminant<A> as Arbitrary>::Strategy
impl Arbitrary for Shutdown
[src]
type Parameters = ()
type Strategy = LazyTupleUnion<((u32, Arc<Just<Shutdown>>), (u32, Arc<Just<Shutdown>>), (u32, Arc<Just<Shutdown>>))>
fn arbitrary_with(
_args: <Shutdown as Arbitrary>::Parameters
) -> <Shutdown as Arbitrary>::Strategy
[src]
_args: <Shutdown as Arbitrary>::Parameters
) -> <Shutdown as Arbitrary>::Strategy
impl Arbitrary for BorrowMutError
[src]
type Parameters = ()
type Strategy = LazyJust<BorrowMutError, fn() -> BorrowMutError>
fn arbitrary_with(
_args: <BorrowMutError as Arbitrary>::Parameters
) -> <BorrowMutError as Arbitrary>::Strategy
[src]
_args: <BorrowMutError as Arbitrary>::Parameters
) -> <BorrowMutError as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 21] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 21]>
fn arbitrary_with(
args: <[A; 21] as Arbitrary>::Parameters
) -> <[A; 21] as Arbitrary>::Strategy
[src]
args: <[A; 21] as Arbitrary>::Parameters
) -> <[A; 21] as Arbitrary>::Strategy
impl Arbitrary for FpCategory
[src]
type Parameters = ()
type Strategy = LazyTupleUnion<((u32, Arc<Just<FpCategory>>), (u32, Arc<Just<FpCategory>>), (u32, Arc<Just<FpCategory>>), (u32, Arc<Just<FpCategory>>), (u32, Arc<Just<FpCategory>>))>
fn arbitrary_with(
_args: <FpCategory as Arbitrary>::Parameters
) -> <FpCategory as Arbitrary>::Strategy
[src]
_args: <FpCategory as Arbitrary>::Parameters
) -> <FpCategory as Arbitrary>::Strategy
impl<A> Arbitrary for IntoIter<A> where
A: Arbitrary + Ord,
[src]
A: Arbitrary + Ord,
type Parameters = <BTreeSet<A> as Arbitrary>::Parameters
type Strategy = Map<<BTreeSet<A> as Arbitrary>::Strategy, fn(BTreeSet<A>) -> IntoIter<A>>
fn arbitrary_with(
args: <IntoIter<A> as Arbitrary>::Parameters
) -> <IntoIter<A> as Arbitrary>::Strategy
[src]
args: <IntoIter<A> as Arbitrary>::Parameters
) -> <IntoIter<A> as Arbitrary>::Strategy
impl Arbitrary for String
[src]
type Parameters = StringParam
type Strategy = &'static str
fn arbitrary_with(
args: <String as Arbitrary>::Parameters
) -> <String as Arbitrary>::Strategy
[src]
args: <String as Arbitrary>::Parameters
) -> <String as Arbitrary>::Strategy
Panics
This implementation panics if the input is not a valid regex proptest can handle.
impl Arbitrary for Once
[src]
type Parameters = ()
type Strategy = LazyJust<Once, fn() -> Once>
fn arbitrary_with(
_args: <Once as Arbitrary>::Parameters
) -> <Once as Arbitrary>::Strategy
[src]
_args: <Once as Arbitrary>::Parameters
) -> <Once as Arbitrary>::Strategy
impl Arbitrary for u128
[src]
type Parameters = ()
type Strategy = Any
fn arbitrary_with(
_args: <u128 as Arbitrary>::Parameters
) -> <u128 as Arbitrary>::Strategy
[src]
_args: <u128 as Arbitrary>::Parameters
) -> <u128 as Arbitrary>::Strategy
impl<A> Arbitrary for Rev<A> where
A: Arbitrary + DoubleEndedIterator,
[src]
A: Arbitrary + DoubleEndedIterator,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> Rev<A>>
fn arbitrary_with(
args: <Rev<A> as Arbitrary>::Parameters
) -> <Rev<A> as Arbitrary>::Strategy
[src]
args: <Rev<A> as Arbitrary>::Parameters
) -> <Rev<A> as Arbitrary>::Strategy
impl Arbitrary for EscapeDefault
[src]
type Parameters = ()
type Strategy = Map<<char as Arbitrary>::Strategy, fn(char) -> EscapeDefault>
fn arbitrary_with(
_args: <EscapeDefault as Arbitrary>::Parameters
) -> <EscapeDefault as Arbitrary>::Strategy
[src]
_args: <EscapeDefault as Arbitrary>::Parameters
) -> <EscapeDefault as Arbitrary>::Strategy
impl Arbitrary for Arc<str>
[src]
type Parameters = StringParam
type Strategy = MapInto<<String as Arbitrary>::Strategy, Arc<str>>
fn arbitrary_with(
a: <Arc<str> as Arbitrary>::Parameters
) -> <Arc<str> as Arbitrary>::Strategy
[src]
a: <Arc<str> as Arbitrary>::Parameters
) -> <Arc<str> as Arbitrary>::Strategy
impl<A> Arbitrary for Cell<A> where
A: Arbitrary + Copy,
[src]
A: Arbitrary + Copy,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = MapInto<<A as Arbitrary>::Strategy, Cell<A>>
fn arbitrary_with(
args: <Cell<A> as Arbitrary>::Parameters
) -> <Cell<A> as Arbitrary>::Strategy
[src]
args: <Cell<A> as Arbitrary>::Parameters
) -> <Cell<A> as Arbitrary>::Strategy
impl Arbitrary for Condvar
[src]
type Parameters = ()
type Strategy = LazyJust<Condvar, fn() -> Condvar>
fn arbitrary_with(
_args: <Condvar as Arbitrary>::Parameters
) -> <Condvar as Arbitrary>::Strategy
[src]
_args: <Condvar as Arbitrary>::Parameters
) -> <Condvar as Arbitrary>::Strategy
impl Arbitrary for Stderr
[src]
type Parameters = ()
type Strategy = LazyJust<Stderr, fn() -> Stderr>
fn arbitrary_with(
_args: <Stderr as Arbitrary>::Parameters
) -> <Stderr as Arbitrary>::Strategy
[src]
_args: <Stderr as Arbitrary>::Parameters
) -> <Stderr as Arbitrary>::Strategy
impl Arbitrary for SocketAddr
[src]
type Parameters = ()
type Strategy = LazyTupleUnion<((u32, Arc<MapInto<<SocketAddrV4 as Arbitrary>::Strategy, SocketAddr>>), (u32, Arc<MapInto<<SocketAddrV6 as Arbitrary>::Strategy, SocketAddr>>))>
fn arbitrary_with(
_args: <SocketAddr as Arbitrary>::Parameters
) -> <SocketAddr as Arbitrary>::Strategy
[src]
_args: <SocketAddr as Arbitrary>::Parameters
) -> <SocketAddr as Arbitrary>::Strategy
impl<A> Arbitrary for BTreeSet<A> where
A: Arbitrary + Ord,
[src]
A: Arbitrary + Ord,
type Parameters = (SizeRange, <A as Arbitrary>::Parameters)
type Strategy = BTreeSetStrategy<<A as Arbitrary>::Strategy>
fn arbitrary_with(
args: <BTreeSet<A> as Arbitrary>::Parameters
) -> <BTreeSet<A> as Arbitrary>::Strategy
[src]
args: <BTreeSet<A> as Arbitrary>::Parameters
) -> <BTreeSet<A> as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 22] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 22]>
fn arbitrary_with(
args: <[A; 22] as Arbitrary>::Parameters
) -> <[A; 22] as Arbitrary>::Strategy
[src]
args: <[A; 22] as Arbitrary>::Parameters
) -> <[A; 22] as Arbitrary>::Strategy
impl Arbitrary for CString
[src]
type Parameters = SizeRange
type Strategy = Map<VecStrategy<RangeInclusive<u8>>, fn(<VecStrategy<RangeInclusive<u8>> as Strategy>::Value) -> CString>
fn arbitrary_with(
args: <CString as Arbitrary>::Parameters
) -> <CString as Arbitrary>::Strategy
[src]
args: <CString as Arbitrary>::Parameters
) -> <CString as Arbitrary>::Strategy
impl<A> Arbitrary for Split<A> where
A: Arbitrary + BufRead,
[src]
A: Arbitrary + BufRead,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<(A, u8) as Arbitrary>::Strategy, fn((A, u8)) -> Split<A>>
fn arbitrary_with(
args: <Split<A> as Arbitrary>::Parameters
) -> <Split<A> as Arbitrary>::Strategy
[src]
args: <Split<A> as Arbitrary>::Parameters
) -> <Split<A> as Arbitrary>::Strategy
impl Arbitrary for VarsOs
[src]
type Parameters = ()
type Strategy = LazyJust<VarsOs, fn() -> VarsOs>
fn arbitrary_with(
_args: <VarsOs as Arbitrary>::Parameters
) -> <VarsOs as Arbitrary>::Strategy
[src]
_args: <VarsOs as Arbitrary>::Parameters
) -> <VarsOs as Arbitrary>::Strategy
impl<A> Arbitrary for RefCell<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = MapInto<<A as Arbitrary>::Strategy, RefCell<A>>
fn arbitrary_with(
args: <RefCell<A> as Arbitrary>::Parameters
) -> <RefCell<A> as Arbitrary>::Strategy
[src]
args: <RefCell<A> as Arbitrary>::Parameters
) -> <RefCell<A> as Arbitrary>::Strategy
impl<A> Arbitrary for Mutex<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> Mutex<A>>
fn arbitrary_with(
args: <Mutex<A> as Arbitrary>::Parameters
) -> <Mutex<A> as Arbitrary>::Strategy
[src]
args: <Mutex<A> as Arbitrary>::Parameters
) -> <Mutex<A> as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 16] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 16]>
fn arbitrary_with(
args: <[A; 16] as Arbitrary>::Parameters
) -> <[A; 16] as Arbitrary>::Strategy
[src]
args: <[A; 16] as Arbitrary>::Parameters
) -> <[A; 16] as Arbitrary>::Strategy
impl Arbitrary for char
[src]
type Parameters = ()
type Strategy = CharStrategy<'static>
fn arbitrary_with(
_args: <char as Arbitrary>::Parameters
) -> <char as Arbitrary>::Strategy
[src]
_args: <char as Arbitrary>::Parameters
) -> <char as Arbitrary>::Strategy
impl<T0, T1, T2, T3, T4, T5, T6, T7> Arbitrary for (T0, T1, T2, T3, T4, T5, T6, T7) where
T0: Arbitrary,
T1: Arbitrary,
T2: Arbitrary,
T3: Arbitrary,
T4: Arbitrary,
T5: Arbitrary,
T6: Arbitrary,
T7: Arbitrary,
[src]
T0: Arbitrary,
T1: Arbitrary,
T2: Arbitrary,
T3: Arbitrary,
T4: Arbitrary,
T5: Arbitrary,
T6: Arbitrary,
T7: Arbitrary,
type Parameters = (<T0 as Arbitrary>::Parameters, <T1 as Arbitrary>::Parameters, <T2 as Arbitrary>::Parameters, <T3 as Arbitrary>::Parameters, <T4 as Arbitrary>::Parameters, <T5 as Arbitrary>::Parameters, <T6 as Arbitrary>::Parameters, <T7 as Arbitrary>::Parameters)
type Strategy = (<T0 as Arbitrary>::Strategy, <T1 as Arbitrary>::Strategy, <T2 as Arbitrary>::Strategy, <T3 as Arbitrary>::Strategy, <T4 as Arbitrary>::Strategy, <T5 as Arbitrary>::Strategy, <T6 as Arbitrary>::Strategy, <T7 as Arbitrary>::Strategy)
fn arbitrary_with(
args: <(T0, T1, T2, T3, T4, T5, T6, T7) as Arbitrary>::Parameters
) -> <(T0, T1, T2, T3, T4, T5, T6, T7) as Arbitrary>::Strategy
[src]
args: <(T0, T1, T2, T3, T4, T5, T6, T7) as Arbitrary>::Parameters
) -> <(T0, T1, T2, T3, T4, T5, T6, T7) as Arbitrary>::Strategy
impl Arbitrary for RecvError
[src]
type Parameters = ()
type Strategy = Just<RecvError>
fn arbitrary_with(
_args: <RecvError as Arbitrary>::Parameters
) -> <RecvError as Arbitrary>::Strategy
[src]
_args: <RecvError as Arbitrary>::Parameters
) -> <RecvError as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 7] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 7]>
fn arbitrary_with(
args: <[A; 7] as Arbitrary>::Parameters
) -> <[A; 7] as Arbitrary>::Strategy
[src]
args: <[A; 7] as Arbitrary>::Parameters
) -> <[A; 7] as Arbitrary>::Strategy
impl<A> Arbitrary for Take<A> where
A: Arbitrary + Iterator,
[src]
A: Arbitrary + Iterator,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<(A, usize) as Arbitrary>::Strategy, fn((A, usize)) -> Take<A>>
fn arbitrary_with(
a: <Take<A> as Arbitrary>::Parameters
) -> <Take<A> as Arbitrary>::Strategy
[src]
a: <Take<A> as Arbitrary>::Parameters
) -> <Take<A> as Arbitrary>::Strategy
impl Arbitrary for Args
[src]
type Parameters = ()
type Strategy = LazyJust<Args, fn() -> Args>
fn arbitrary_with(
_args: <Args as Arbitrary>::Parameters
) -> <Args as Arbitrary>::Strategy
[src]
_args: <Args as Arbitrary>::Parameters
) -> <Args as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 17] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 17]>
fn arbitrary_with(
args: <[A; 17] as Arbitrary>::Parameters
) -> <[A; 17] as Arbitrary>::Strategy
[src]
args: <[A; 17] as Arbitrary>::Parameters
) -> <[A; 17] as Arbitrary>::Strategy
impl Arbitrary for IpAddr
[src]
type Parameters = ()
type Strategy = LazyTupleUnion<((u32, Arc<MapInto<<Ipv4Addr as Arbitrary>::Strategy, IpAddr>>), (u32, Arc<MapInto<<Ipv6Addr as Arbitrary>::Strategy, IpAddr>>))>
fn arbitrary_with(
_args: <IpAddr as Arbitrary>::Parameters
) -> <IpAddr as Arbitrary>::Strategy
[src]
_args: <IpAddr as Arbitrary>::Parameters
) -> <IpAddr as Arbitrary>::Strategy
impl Arbitrary for SystemTime
[src]
type Parameters = ()
type Strategy = Map<(Any, Range<u32>), fn((i32, u32)) -> SystemTime>
fn arbitrary_with(
_args: <SystemTime as Arbitrary>::Parameters
) -> <SystemTime as Arbitrary>::Strategy
[src]
_args: <SystemTime as Arbitrary>::Parameters
) -> <SystemTime as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 19] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 19]>
fn arbitrary_with(
args: <[A; 19] as Arbitrary>::Parameters
) -> <[A; 19] as Arbitrary>::Strategy
[src]
args: <[A; 19] as Arbitrary>::Parameters
) -> <[A; 19] as Arbitrary>::Strategy
impl Arbitrary for Option<!>
[src]
type Parameters = ()
type Strategy = Just<Option<!>>
fn arbitrary_with(
_args: <Option<!> as Arbitrary>::Parameters
) -> <Option<!> as Arbitrary>::Strategy
[src]
_args: <Option<!> as Arbitrary>::Parameters
) -> <Option<!> as Arbitrary>::Strategy
impl<A, B> Arbitrary for Result<A, B> where
A: Arbitrary,
B: Arbitrary,
[src]
A: Arbitrary,
B: Arbitrary,
type Parameters = (Probability, <A as Arbitrary>::Parameters, <B as Arbitrary>::Parameters)
type Strategy = MaybeOk<<A as Arbitrary>::Strategy, <B as Arbitrary>::Strategy>
fn arbitrary_with(
args: <Result<A, B> as Arbitrary>::Parameters
) -> <Result<A, B> as Arbitrary>::Strategy
[src]
args: <Result<A, B> as Arbitrary>::Parameters
) -> <Result<A, B> as Arbitrary>::Strategy
impl Arbitrary for EscapeDefault
[src]
type Parameters = ()
type Strategy = Map<<u8 as Arbitrary>::Strategy, fn(u8) -> EscapeDefault>
fn arbitrary_with(
_args: <EscapeDefault as Arbitrary>::Parameters
) -> <EscapeDefault as Arbitrary>::Strategy
[src]
_args: <EscapeDefault as Arbitrary>::Parameters
) -> <EscapeDefault as Arbitrary>::Strategy
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Arbitrary for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
T0: Arbitrary,
T1: Arbitrary,
T2: Arbitrary,
T3: Arbitrary,
T4: Arbitrary,
T5: Arbitrary,
T6: Arbitrary,
T7: Arbitrary,
T8: Arbitrary,
[src]
T0: Arbitrary,
T1: Arbitrary,
T2: Arbitrary,
T3: Arbitrary,
T4: Arbitrary,
T5: Arbitrary,
T6: Arbitrary,
T7: Arbitrary,
T8: Arbitrary,
type Parameters = (<T0 as Arbitrary>::Parameters, <T1 as Arbitrary>::Parameters, <T2 as Arbitrary>::Parameters, <T3 as Arbitrary>::Parameters, <T4 as Arbitrary>::Parameters, <T5 as Arbitrary>::Parameters, <T6 as Arbitrary>::Parameters, <T7 as Arbitrary>::Parameters, <T8 as Arbitrary>::Parameters)
type Strategy = (<T0 as Arbitrary>::Strategy, <T1 as Arbitrary>::Strategy, <T2 as Arbitrary>::Strategy, <T3 as Arbitrary>::Strategy, <T4 as Arbitrary>::Strategy, <T5 as Arbitrary>::Strategy, <T6 as Arbitrary>::Strategy, <T7 as Arbitrary>::Strategy, <T8 as Arbitrary>::Strategy)
fn arbitrary_with(
args: <(T0, T1, T2, T3, T4, T5, T6, T7, T8) as Arbitrary>::Parameters
) -> <(T0, T1, T2, T3, T4, T5, T6, T7, T8) as Arbitrary>::Strategy
[src]
args: <(T0, T1, T2, T3, T4, T5, T6, T7, T8) as Arbitrary>::Parameters
) -> <(T0, T1, T2, T3, T4, T5, T6, T7, T8) as Arbitrary>::Strategy
impl Arbitrary for i16
[src]
type Parameters = ()
type Strategy = Any
fn arbitrary_with(
_args: <i16 as Arbitrary>::Parameters
) -> <i16 as Arbitrary>::Strategy
[src]
_args: <i16 as Arbitrary>::Parameters
) -> <i16 as Arbitrary>::Strategy
impl<A> Arbitrary for (SyncSender<A>, Receiver<A>)
[src]
type Parameters = ()
type Strategy = Map<<u16 as Arbitrary>::Strategy, fn(u16) -> (SyncSender<A>, Receiver<A>)>
fn arbitrary_with(
_args: <(SyncSender<A>, Receiver<A>) as Arbitrary>::Parameters
) -> <(SyncSender<A>, Receiver<A>) as Arbitrary>::Strategy
[src]
_args: <(SyncSender<A>, Receiver<A>) as Arbitrary>::Parameters
) -> <(SyncSender<A>, Receiver<A>) as Arbitrary>::Strategy
impl<A, B> Arbitrary for IntoIter<A, B> where
A: Arbitrary + Eq + Hash,
B: Arbitrary,
[src]
A: Arbitrary + Eq + Hash,
B: Arbitrary,
type Parameters = <HashMap<A, B, RandomState> as Arbitrary>::Parameters
type Strategy = Map<<HashMap<A, B, RandomState> as Arbitrary>::Strategy, fn(HashMap<A, B, RandomState>) -> IntoIter<A, B>>
fn arbitrary_with(
args: <IntoIter<A, B> as Arbitrary>::Parameters
) -> <IntoIter<A, B> as Arbitrary>::Strategy
[src]
args: <IntoIter<A, B> as Arbitrary>::Parameters
) -> <IntoIter<A, B> as Arbitrary>::Strategy
impl Arbitrary for DecodeUtf16<<Vec<u16> as IntoIterator>::IntoIter>
[src]
type Parameters = ()
type Strategy = Map<<Vec<u16> as Arbitrary>::Strategy, fn(Vec<u16>) -> DecodeUtf16<<Vec<u16> as IntoIterator>::IntoIter>>
fn arbitrary_with(
_args: <DecodeUtf16<<Vec<u16> as IntoIterator>::IntoIter> as Arbitrary>::Parameters
) -> <DecodeUtf16<<Vec<u16> as IntoIterator>::IntoIter> as Arbitrary>::Strategy
[src]
_args: <DecodeUtf16<<Vec<u16> as IntoIterator>::IntoIter> as Arbitrary>::Parameters
) -> <DecodeUtf16<<Vec<u16> as IntoIterator>::IntoIter> as Arbitrary>::Strategy
impl Arbitrary for Rc<str>
[src]
type Parameters = StringParam
type Strategy = MapInto<<String as Arbitrary>::Strategy, Rc<str>>
fn arbitrary_with(
a: <Rc<str> as Arbitrary>::Parameters
) -> <Rc<str> as Arbitrary>::Strategy
[src]
a: <Rc<str> as Arbitrary>::Parameters
) -> <Rc<str> as Arbitrary>::Strategy
impl Arbitrary for Barrier
[src]
type Parameters = ()
type Strategy = Map<<u16 as Arbitrary>::Strategy, fn(u16) -> Barrier>
fn arbitrary_with(
_args: <Barrier as Arbitrary>::Parameters
) -> <Barrier as Arbitrary>::Strategy
[src]
_args: <Barrier as Arbitrary>::Parameters
) -> <Barrier as Arbitrary>::Strategy
impl<T0, T1, T2, T3, T4, T5> Arbitrary for (T0, T1, T2, T3, T4, T5) where
T0: Arbitrary,
T1: Arbitrary,
T2: Arbitrary,
T3: Arbitrary,
T4: Arbitrary,
T5: Arbitrary,
[src]
T0: Arbitrary,
T1: Arbitrary,
T2: Arbitrary,
T3: Arbitrary,
T4: Arbitrary,
T5: Arbitrary,
type Parameters = (<T0 as Arbitrary>::Parameters, <T1 as Arbitrary>::Parameters, <T2 as Arbitrary>::Parameters, <T3 as Arbitrary>::Parameters, <T4 as Arbitrary>::Parameters, <T5 as Arbitrary>::Parameters)
type Strategy = (<T0 as Arbitrary>::Strategy, <T1 as Arbitrary>::Strategy, <T2 as Arbitrary>::Strategy, <T3 as Arbitrary>::Strategy, <T4 as Arbitrary>::Strategy, <T5 as Arbitrary>::Strategy)
fn arbitrary_with(
args: <(T0, T1, T2, T3, T4, T5) as Arbitrary>::Parameters
) -> <(T0, T1, T2, T3, T4, T5) as Arbitrary>::Strategy
[src]
args: <(T0, T1, T2, T3, T4, T5) as Arbitrary>::Parameters
) -> <(T0, T1, T2, T3, T4, T5) as Arbitrary>::Strategy
impl Arbitrary for bool
[src]
type Parameters = ()
type Strategy = Any
fn arbitrary_with(
_args: <bool as Arbitrary>::Parameters
) -> <bool as Arbitrary>::Strategy
[src]
_args: <bool as Arbitrary>::Parameters
) -> <bool as Arbitrary>::Strategy
impl Arbitrary for SeekFrom
[src]
type Parameters = ()
type Strategy = LazyTupleUnion<((u32, Arc<Map<<u64 as Arbitrary>::Strategy, fn(u64) -> SeekFrom>>), (u32, Arc<Map<<i64 as Arbitrary>::Strategy, fn(i64) -> SeekFrom>>), (u32, Arc<Map<<i64 as Arbitrary>::Strategy, fn(i64) -> SeekFrom>>))>
fn arbitrary_with(
_args: <SeekFrom as Arbitrary>::Parameters
) -> <SeekFrom as Arbitrary>::Strategy
[src]
_args: <SeekFrom as Arbitrary>::Parameters
) -> <SeekFrom as Arbitrary>::Strategy
impl Arbitrary for Error
[src]
type Parameters = ()
type Strategy = Just<Error>
fn arbitrary_with(
_args: <Error as Arbitrary>::Parameters
) -> <Error as Arbitrary>::Strategy
[src]
_args: <Error as Arbitrary>::Parameters
) -> <Error as Arbitrary>::Strategy
impl Arbitrary for Box<str>
[src]
type Parameters = StringParam
type Strategy = MapInto<<String as Arbitrary>::Strategy, Box<str>>
fn arbitrary_with(
a: <Box<str> as Arbitrary>::Parameters
) -> <Box<str> as Arbitrary>::Strategy
[src]
a: <Box<str> as Arbitrary>::Parameters
) -> <Box<str> as Arbitrary>::Strategy
impl<T> Arbitrary for SendError<T> where
T: Arbitrary,
[src]
T: Arbitrary,
type Parameters = <T as Arbitrary>::Parameters
type Strategy = Map<<T as Arbitrary>::Strategy, fn(T) -> SendError<T>>
fn arbitrary_with(
args: <SendError<T> as Arbitrary>::Parameters
) -> <SendError<T> as Arbitrary>::Strategy
[src]
args: <SendError<T> as Arbitrary>::Parameters
) -> <SendError<T> as Arbitrary>::Strategy
impl Arbitrary for FromUtf8Error
[src]
type Parameters = ()
type Strategy = Map<BoxedStrategy<Vec<u8>>, fn(<BoxedStrategy<Vec<u8>> as Strategy>::Value) -> FromUtf8Error>
fn arbitrary_with(
_args: <FromUtf8Error as Arbitrary>::Parameters
) -> <FromUtf8Error as Arbitrary>::Strategy
[src]
_args: <FromUtf8Error as Arbitrary>::Parameters
) -> <FromUtf8Error as Arbitrary>::Strategy
impl Arbitrary for f64
[src]
type Parameters = ()
type Strategy = Any
fn arbitrary_with(
_args: <f64 as Arbitrary>::Parameters
) -> <f64 as Arbitrary>::Strategy
[src]
_args: <f64 as Arbitrary>::Parameters
) -> <f64 as Arbitrary>::Strategy
impl<A> Arbitrary for Arc<[A]> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <Vec<A> as Arbitrary>::Parameters
type Strategy = MapInto<<Vec<A> as Arbitrary>::Strategy, Arc<[A]>>
fn arbitrary_with(
a: <Arc<[A]> as Arbitrary>::Parameters
) -> <Arc<[A]> as Arbitrary>::Strategy
[src]
a: <Arc<[A]> as Arbitrary>::Parameters
) -> <Arc<[A]> as Arbitrary>::Strategy
impl Arbitrary for Ordering
[src]
type Parameters = ()
type Strategy = LazyTupleUnion<((u32, Arc<Just<Ordering>>), (u32, Arc<Just<Ordering>>), (u32, Arc<Just<Ordering>>))>
fn arbitrary_with(
_args: <Ordering as Arbitrary>::Parameters
) -> <Ordering as Arbitrary>::Strategy
[src]
_args: <Ordering as Arbitrary>::Parameters
) -> <Ordering as Arbitrary>::Strategy
impl Arbitrary for EscapeUnicode
[src]
type Parameters = ()
type Strategy = Map<<char as Arbitrary>::Strategy, fn(char) -> EscapeUnicode>
fn arbitrary_with(
_args: <EscapeUnicode as Arbitrary>::Parameters
) -> <EscapeUnicode as Arbitrary>::Strategy
[src]
_args: <EscapeUnicode as Arbitrary>::Parameters
) -> <EscapeUnicode as Arbitrary>::Strategy
impl Arbitrary for RecvTimeoutError
[src]
type Parameters = ()
type Strategy = LazyTupleUnion<((u32, Arc<Just<RecvTimeoutError>>), (u32, Arc<Just<RecvTimeoutError>>))>
fn arbitrary_with(
_args: <RecvTimeoutError as Arbitrary>::Parameters
) -> <RecvTimeoutError as Arbitrary>::Strategy
[src]
_args: <RecvTimeoutError as Arbitrary>::Parameters
) -> <RecvTimeoutError as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 32] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 32]>
fn arbitrary_with(
args: <[A; 32] as Arbitrary>::Parameters
) -> <[A; 32] as Arbitrary>::Strategy
[src]
args: <[A; 32] as Arbitrary>::Parameters
) -> <[A; 32] as Arbitrary>::Strategy
impl<A> Arbitrary for Vec<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = (SizeRange, <A as Arbitrary>::Parameters)
type Strategy = VecStrategy<<A as Arbitrary>::Strategy>
fn arbitrary_with(
args: <Vec<A> as Arbitrary>::Parameters
) -> <Vec<A> as Arbitrary>::Strategy
[src]
args: <Vec<A> as Arbitrary>::Parameters
) -> <Vec<A> as Arbitrary>::Strategy
impl Arbitrary for ParseFloatError
[src]
type Parameters = ()
type Strategy = Just<ParseFloatError>
fn arbitrary_with(
_args: <ParseFloatError as Arbitrary>::Parameters
) -> <ParseFloatError as Arbitrary>::Strategy
[src]
_args: <ParseFloatError as Arbitrary>::Parameters
) -> <ParseFloatError as Arbitrary>::Strategy
impl<A> Arbitrary for Wrapping<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> Wrapping<A>>
fn arbitrary_with(
args: <Wrapping<A> as Arbitrary>::Parameters
) -> <Wrapping<A> as Arbitrary>::Strategy
[src]
args: <Wrapping<A> as Arbitrary>::Parameters
) -> <Wrapping<A> as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 20] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 20]>
fn arbitrary_with(
args: <[A; 20] as Arbitrary>::Parameters
) -> <[A; 20] as Arbitrary>::Strategy
[src]
args: <[A; 20] as Arbitrary>::Parameters
) -> <[A; 20] as Arbitrary>::Strategy
impl Arbitrary for Sink
[src]
type Parameters = ()
type Strategy = LazyJust<Sink, fn() -> Sink>
fn arbitrary_with(
_args: <Sink as Arbitrary>::Parameters
) -> <Sink as Arbitrary>::Strategy
[src]
_args: <Sink as Arbitrary>::Parameters
) -> <Sink as Arbitrary>::Strategy
impl Arbitrary for AtomicBool
[src]
type Parameters = ()
type Strategy = Map<<bool as Arbitrary>::Strategy, fn(bool) -> AtomicBool>
fn arbitrary_with(
_args: <AtomicBool as Arbitrary>::Parameters
) -> <AtomicBool as Arbitrary>::Strategy
[src]
_args: <AtomicBool as Arbitrary>::Parameters
) -> <AtomicBool as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 13] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 13]>
fn arbitrary_with(
args: <[A; 13] as Arbitrary>::Parameters
) -> <[A; 13] as Arbitrary>::Strategy
[src]
args: <[A; 13] as Arbitrary>::Parameters
) -> <[A; 13] as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 3] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 3]>
fn arbitrary_with(
args: <[A; 3] as Arbitrary>::Parameters
) -> <[A; 3] as Arbitrary>::Strategy
[src]
args: <[A; 3] as Arbitrary>::Parameters
) -> <[A; 3] as Arbitrary>::Strategy
impl Arbitrary for i64
[src]
type Parameters = ()
type Strategy = Any
fn arbitrary_with(
_args: <i64 as Arbitrary>::Parameters
) -> <i64 as Arbitrary>::Strategy
[src]
_args: <i64 as Arbitrary>::Parameters
) -> <i64 as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 28] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 28]>
fn arbitrary_with(
args: <[A; 28] as Arbitrary>::Parameters
) -> <[A; 28] as Arbitrary>::Strategy
[src]
args: <[A; 28] as Arbitrary>::Parameters
) -> <[A; 28] as Arbitrary>::Strategy
impl Arbitrary for ParseBoolError
[src]
type Parameters = ()
type Strategy = Just<ParseBoolError>
fn arbitrary_with(
_args: <ParseBoolError as Arbitrary>::Parameters
) -> <ParseBoolError as Arbitrary>::Strategy
[src]
_args: <ParseBoolError as Arbitrary>::Parameters
) -> <ParseBoolError as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 25] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 25]>
fn arbitrary_with(
args: <[A; 25] as Arbitrary>::Parameters
) -> <[A; 25] as Arbitrary>::Strategy
[src]
args: <[A; 25] as Arbitrary>::Parameters
) -> <[A; 25] as Arbitrary>::Strategy
impl<A> Arbitrary for RwLock<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> RwLock<A>>
fn arbitrary_with(
args: <RwLock<A> as Arbitrary>::Parameters
) -> <RwLock<A> as Arbitrary>::Strategy
[src]
args: <RwLock<A> as Arbitrary>::Parameters
) -> <RwLock<A> as Arbitrary>::Strategy
impl<A> Arbitrary for Lines<A> where
A: Arbitrary + BufRead,
[src]
A: Arbitrary + BufRead,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> Lines<A>>
fn arbitrary_with(
args: <Lines<A> as Arbitrary>::Parameters
) -> <Lines<A> as Arbitrary>::Strategy
[src]
args: <Lines<A> as Arbitrary>::Parameters
) -> <Lines<A> as Arbitrary>::Strategy
impl Arbitrary for SocketAddrV6
[src]
type Parameters = ()
type Strategy = Map<<(Ipv6Addr, u16, u32, u32) as Arbitrary>::Strategy, fn((Ipv6Addr, u16, u32, u32)) -> SocketAddrV6>
fn arbitrary_with(
_args: <SocketAddrV6 as Arbitrary>::Parameters
) -> <SocketAddrV6 as Arbitrary>::Strategy
[src]
_args: <SocketAddrV6 as Arbitrary>::Parameters
) -> <SocketAddrV6 as Arbitrary>::Strategy
impl<A> Arbitrary for (Sender<A>, Receiver<A>)
[src]
type Parameters = ()
type Strategy = LazyJust<(Sender<A>, Receiver<A>), fn() -> (Sender<A>, Receiver<A>)>
fn arbitrary_with(
_args: <(Sender<A>, Receiver<A>) as Arbitrary>::Parameters
) -> <(Sender<A>, Receiver<A>) as Arbitrary>::Strategy
[src]
_args: <(Sender<A>, Receiver<A>) as Arbitrary>::Parameters
) -> <(Sender<A>, Receiver<A>) as Arbitrary>::Strategy
impl<A> Arbitrary for VecDeque<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = (SizeRange, <A as Arbitrary>::Parameters)
type Strategy = VecDequeStrategy<<A as Arbitrary>::Strategy>
fn arbitrary_with(
args: <VecDeque<A> as Arbitrary>::Parameters
) -> <VecDeque<A> as Arbitrary>::Strategy
[src]
args: <VecDeque<A> as Arbitrary>::Parameters
) -> <VecDeque<A> as Arbitrary>::Strategy
impl Arbitrary for BorrowError
[src]
type Parameters = ()
type Strategy = LazyJust<BorrowError, fn() -> BorrowError>
fn arbitrary_with(
_args: <BorrowError as Arbitrary>::Parameters
) -> <BorrowError as Arbitrary>::Strategy
[src]
_args: <BorrowError as Arbitrary>::Parameters
) -> <BorrowError as Arbitrary>::Strategy
impl Arbitrary for SocketAddrV4
[src]
type Parameters = ()
type Strategy = Map<<(Ipv4Addr, u16) as Arbitrary>::Strategy, fn((Ipv4Addr, u16)) -> SocketAddrV4>
fn arbitrary_with(
_args: <SocketAddrV4 as Arbitrary>::Parameters
) -> <SocketAddrV4 as Arbitrary>::Strategy
[src]
_args: <SocketAddrV4 as Arbitrary>::Parameters
) -> <SocketAddrV4 as Arbitrary>::Strategy
impl<T0, T1, T2, T3, T4> Arbitrary for (T0, T1, T2, T3, T4) where
T0: Arbitrary,
T1: Arbitrary,
T2: Arbitrary,
T3: Arbitrary,
T4: Arbitrary,
[src]
T0: Arbitrary,
T1: Arbitrary,
T2: Arbitrary,
T3: Arbitrary,
T4: Arbitrary,
type Parameters = (<T0 as Arbitrary>::Parameters, <T1 as Arbitrary>::Parameters, <T2 as Arbitrary>::Parameters, <T3 as Arbitrary>::Parameters, <T4 as Arbitrary>::Parameters)
type Strategy = (<T0 as Arbitrary>::Strategy, <T1 as Arbitrary>::Strategy, <T2 as Arbitrary>::Strategy, <T3 as Arbitrary>::Strategy, <T4 as Arbitrary>::Strategy)
fn arbitrary_with(
args: <(T0, T1, T2, T3, T4) as Arbitrary>::Parameters
) -> <(T0, T1, T2, T3, T4) as Arbitrary>::Strategy
[src]
args: <(T0, T1, T2, T3, T4) as Arbitrary>::Parameters
) -> <(T0, T1, T2, T3, T4) as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 12] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 12]>
fn arbitrary_with(
args: <[A; 12] as Arbitrary>::Parameters
) -> <[A; 12] as Arbitrary>::Strategy
[src]
args: <[A; 12] as Arbitrary>::Parameters
) -> <[A; 12] as Arbitrary>::Strategy
impl Arbitrary for i8
[src]
type Parameters = ()
type Strategy = Any
fn arbitrary_with(
_args: <i8 as Arbitrary>::Parameters
) -> <i8 as Arbitrary>::Strategy
[src]
_args: <i8 as Arbitrary>::Parameters
) -> <i8 as Arbitrary>::Strategy
impl<A> Arbitrary for Empty<A>
[src]
type Parameters = ()
type Strategy = Just<Empty<A>>
fn arbitrary_with(
_args: <Empty<A> as Arbitrary>::Parameters
) -> <Empty<A> as Arbitrary>::Strategy
[src]
_args: <Empty<A> as Arbitrary>::Parameters
) -> <Empty<A> as Arbitrary>::Strategy
impl Arbitrary for RandomState
[src]
type Parameters = ()
type Strategy = LazyJust<RandomState, fn() -> RandomState>
fn arbitrary_with(
_args: <RandomState as Arbitrary>::Parameters
) -> <RandomState as Arbitrary>::Strategy
[src]
_args: <RandomState as Arbitrary>::Parameters
) -> <RandomState as Arbitrary>::Strategy
impl Arbitrary for Empty
[src]
type Parameters = ()
type Strategy = LazyJust<Empty, fn() -> Empty>
fn arbitrary_with(
_args: <Empty as Arbitrary>::Parameters
) -> <Empty as Arbitrary>::Strategy
[src]
_args: <Empty as Arbitrary>::Parameters
) -> <Empty as Arbitrary>::Strategy
impl Arbitrary for Builder
[src]
type Parameters = ()
type Strategy = Map<<(Option<usize>, Option<String>) as Arbitrary>::Strategy, fn((Option<usize>, Option<String>)) -> Builder>
fn arbitrary_with(
_args: <Builder as Arbitrary>::Parameters
) -> <Builder as Arbitrary>::Strategy
[src]
_args: <Builder as Arbitrary>::Parameters
) -> <Builder as Arbitrary>::Strategy
impl Arbitrary for AtomicUsize
[src]
type Parameters = ()
type Strategy = Map<<usize as Arbitrary>::Strategy, fn(usize) -> AtomicUsize>
fn arbitrary_with(
_args: <AtomicUsize as Arbitrary>::Parameters
) -> <AtomicUsize as Arbitrary>::Strategy
[src]
_args: <AtomicUsize as Arbitrary>::Parameters
) -> <AtomicUsize as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 24] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 24]>
fn arbitrary_with(
args: <[A; 24] as Arbitrary>::Parameters
) -> <[A; 24] as Arbitrary>::Strategy
[src]
args: <[A; 24] as Arbitrary>::Parameters
) -> <[A; 24] as Arbitrary>::Strategy
impl Arbitrary for DecodeUtf16Error
[src]
type Parameters = ()
type Strategy = Map<Range<u16>, fn(<Range<u16> as Strategy>::Value) -> DecodeUtf16Error>
fn arbitrary_with(
_args: <DecodeUtf16Error as Arbitrary>::Parameters
) -> <DecodeUtf16Error as Arbitrary>::Strategy
[src]
_args: <DecodeUtf16Error as Arbitrary>::Parameters
) -> <DecodeUtf16Error as Arbitrary>::Strategy
impl Arbitrary for ErrorKind
[src]
type Parameters = ()
type Strategy = Union<Just<ErrorKind>>
fn arbitrary_with(
_args: <ErrorKind as Arbitrary>::Parameters
) -> <ErrorKind as Arbitrary>::Strategy
[src]
_args: <ErrorKind as Arbitrary>::Parameters
) -> <ErrorKind as Arbitrary>::Strategy
impl Arbitrary for FromUtf16Error
[src]
type Parameters = ()
type Strategy = LazyJust<FromUtf16Error, fn() -> FromUtf16Error>
fn arbitrary_with(
_args: <FromUtf16Error as Arbitrary>::Parameters
) -> <FromUtf16Error as Arbitrary>::Strategy
[src]
_args: <FromUtf16Error as Arbitrary>::Parameters
) -> <FromUtf16Error as Arbitrary>::Strategy
impl<T0, T1, T2, T3> Arbitrary for (T0, T1, T2, T3) where
T0: Arbitrary,
T1: Arbitrary,
T2: Arbitrary,
T3: Arbitrary,
[src]
T0: Arbitrary,
T1: Arbitrary,
T2: Arbitrary,
T3: Arbitrary,
type Parameters = (<T0 as Arbitrary>::Parameters, <T1 as Arbitrary>::Parameters, <T2 as Arbitrary>::Parameters, <T3 as Arbitrary>::Parameters)
type Strategy = (<T0 as Arbitrary>::Strategy, <T1 as Arbitrary>::Strategy, <T2 as Arbitrary>::Strategy, <T3 as Arbitrary>::Strategy)
fn arbitrary_with(
args: <(T0, T1, T2, T3) as Arbitrary>::Parameters
) -> <(T0, T1, T2, T3) as Arbitrary>::Strategy
[src]
args: <(T0, T1, T2, T3) as Arbitrary>::Parameters
) -> <(T0, T1, T2, T3) as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 5] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 5]>
fn arbitrary_with(
args: <[A; 5] as Arbitrary>::Parameters
) -> <[A; 5] as Arbitrary>::Strategy
[src]
args: <[A; 5] as Arbitrary>::Parameters
) -> <[A; 5] as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 15] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 15]>
fn arbitrary_with(
args: <[A; 15] as Arbitrary>::Parameters
) -> <[A; 15] as Arbitrary>::Strategy
[src]
args: <[A; 15] as Arbitrary>::Parameters
) -> <[A; 15] as Arbitrary>::Strategy
impl<A> Arbitrary for Box<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = MapInto<<A as Arbitrary>::Strategy, Box<A>>
fn arbitrary_with(
args: <Box<A> as Arbitrary>::Parameters
) -> <Box<A> as Arbitrary>::Strategy
[src]
args: <Box<A> as Arbitrary>::Parameters
) -> <Box<A> as Arbitrary>::Strategy
impl<A> Arbitrary for Option<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = (Probability, <A as Arbitrary>::Parameters)
type Strategy = OptionStrategy<<A as Arbitrary>::Strategy>
fn arbitrary_with(
args: <Option<A> as Arbitrary>::Parameters
) -> <Option<A> as Arbitrary>::Strategy
[src]
args: <Option<A> as Arbitrary>::Parameters
) -> <Option<A> as Arbitrary>::Strategy
impl Arbitrary for Stdout
[src]
type Parameters = ()
type Strategy = LazyJust<Stdout, fn() -> Stdout>
fn arbitrary_with(
_args: <Stdout as Arbitrary>::Parameters
) -> <Stdout as Arbitrary>::Strategy
[src]
_args: <Stdout as Arbitrary>::Parameters
) -> <Stdout as Arbitrary>::Strategy
impl<A> Arbitrary for IntoIter<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <Option<A> as Arbitrary>::Parameters
type Strategy = Map<<Option<A> as Arbitrary>::Strategy, fn(Option<A>) -> IntoIter<A>>
fn arbitrary_with(
args: <IntoIter<A> as Arbitrary>::Parameters
) -> <IntoIter<A> as Arbitrary>::Strategy
[src]
args: <IntoIter<A> as Arbitrary>::Parameters
) -> <IntoIter<A> as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 11] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 11]>
fn arbitrary_with(
args: <[A; 11] as Arbitrary>::Parameters
) -> <[A; 11] as Arbitrary>::Strategy
[src]
args: <[A; 11] as Arbitrary>::Parameters
) -> <[A; 11] as Arbitrary>::Strategy
impl<A> Arbitrary for [A; 18] where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = UniformArrayStrategy<<A as Arbitrary>::Strategy, [A; 18]>
fn arbitrary_with(
args: <[A; 18] as Arbitrary>::Parameters
) -> <[A; 18] as Arbitrary>::Strategy
[src]
args: <[A; 18] as Arbitrary>::Parameters
) -> <[A; 18] as Arbitrary>::Strategy
impl<A, B> Arbitrary for Cow<'static, B> where
A: Arbitrary + Borrow<B>,
B: Debug + ToOwned<Owned = A>,
[src]
A: Arbitrary + Borrow<B>,
B: Debug + ToOwned<Owned = A>,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> Cow<'static, B>>
fn arbitrary_with(
args: <Cow<'static, B> as Arbitrary>::Parameters
) -> <Cow<'static, B> as Arbitrary>::Strategy
[src]
args: <Cow<'static, B> as Arbitrary>::Parameters
) -> <Cow<'static, B> as Arbitrary>::Strategy
impl Arbitrary for ParseIntError
[src]
type Parameters = ()
type Strategy = Just<ParseIntError>
fn arbitrary_with(
_args: <ParseIntError as Arbitrary>::Parameters
) -> <ParseIntError as Arbitrary>::Strategy
[src]
_args: <ParseIntError as Arbitrary>::Parameters
) -> <ParseIntError as Arbitrary>::Strategy
impl Arbitrary for OsString
[src]
type Parameters = <String as Arbitrary>::Parameters
type Strategy = MapInto<<String as Arbitrary>::Strategy, OsString>
fn arbitrary_with(
a: <OsString as Arbitrary>::Parameters
) -> <OsString as Arbitrary>::Strategy
[src]
a: <OsString as Arbitrary>::Parameters
) -> <OsString as Arbitrary>::Strategy
impl Arbitrary for usize
[src]
type Parameters = ()
type Strategy = Any
fn arbitrary_with(
_args: <usize as Arbitrary>::Parameters
) -> <usize as Arbitrary>::Strategy
[src]
_args: <usize as Arbitrary>::Parameters
) -> <usize as Arbitrary>::Strategy
impl Arbitrary for AtomicIsize
[src]
type Parameters = ()
type Strategy = Map<<isize as Arbitrary>::Strategy, fn(isize) -> AtomicIsize>
fn arbitrary_with(
_args: <AtomicIsize as Arbitrary>::Parameters
) -> <AtomicIsize as Arbitrary>::Strategy
[src]
_args: <AtomicIsize as Arbitrary>::Parameters
) -> <AtomicIsize as Arbitrary>::Strategy
impl<A> Arbitrary for BufWriter<A> where
A: Arbitrary + Write,
[src]
A: Arbitrary + Write,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<(A, Option<u16>) as Arbitrary>::Strategy, fn((A, Option<u16>)) -> BufWriter<A>>
fn arbitrary_with(
args: <BufWriter<A> as Arbitrary>::Parameters
) -> <BufWriter<A> as Arbitrary>::Strategy
[src]
args: <BufWriter<A> as Arbitrary>::Parameters
) -> <BufWriter<A> as Arbitrary>::Strategy
impl Arbitrary for BarrierWaitResult
[src]
type Parameters = ()
type Strategy = LazyTupleUnion<((u32, Arc<LazyJust<BarrierWaitResult, fn() -> BarrierWaitResult>>), (u32, Arc<LazyJust<BarrierWaitResult, fn() -> BarrierWaitResult>>))>
fn arbitrary_with(
_args: <BarrierWaitResult as Arbitrary>::Parameters
) -> <BarrierWaitResult as Arbitrary>::Strategy
[src]
_args: <BarrierWaitResult as Arbitrary>::Parameters
) -> <BarrierWaitResult as Arbitrary>::Strategy
impl Arbitrary for StripPrefixError
[src]
type Parameters = ()
type Strategy = Just<StripPrefixError>
fn arbitrary_with(
_args: <StripPrefixError as Arbitrary>::Parameters
) -> <StripPrefixError as Arbitrary>::Strategy
[src]
_args: <StripPrefixError as Arbitrary>::Parameters
) -> <StripPrefixError as Arbitrary>::Strategy
impl Arbitrary for Ipv6Addr
[src]
type Parameters = ()
type Strategy = LazyTupleUnion<((u32, Arc<Map<<Ipv4Addr as Arbitrary>::Strategy, fn(Ipv4Addr) -> Ipv6Addr>>), (u32, Arc<MapInto<<[u16; 8] as Arbitrary>::Strategy, Ipv6Addr>>))>
fn arbitrary_with(
_args: <Ipv6Addr as Arbitrary>::Parameters
) -> <Ipv6Addr as Arbitrary>::Strategy
[src]
_args: <Ipv6Addr as Arbitrary>::Parameters
) -> <Ipv6Addr as Arbitrary>::Strategy
impl<A> Arbitrary for AssertUnwindSafe<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> AssertUnwindSafe<A>>
fn arbitrary_with(
args: <AssertUnwindSafe<A> as Arbitrary>::Parameters
) -> <AssertUnwindSafe<A> as Arbitrary>::Strategy
[src]
args: <AssertUnwindSafe<A> as Arbitrary>::Parameters
) -> <AssertUnwindSafe<A> as Arbitrary>::Strategy
impl Arbitrary for FromBytesWithNulError
[src]
type Parameters = ()
type Strategy = Map<<Option<u16> as Arbitrary>::Strategy, fn(Option<u16>) -> FromBytesWithNulError>
fn arbitrary_with(
_args: <FromBytesWithNulError as Arbitrary>::Parameters
) -> <FromBytesWithNulError as Arbitrary>::Strategy
[src]
_args: <FromBytesWithNulError as Arbitrary>::Parameters
) -> <FromBytesWithNulError as Arbitrary>::Strategy
impl Arbitrary for ParseCharError
[src]
type Parameters = ()
type Strategy = IndFlatten<Map<<bool as Arbitrary>::Strategy, fn(bool) -> Just<ParseCharError>>>
fn arbitrary_with(
_args: <ParseCharError as Arbitrary>::Parameters
) -> <ParseCharError as Arbitrary>::Strategy
[src]
_args: <ParseCharError as Arbitrary>::Parameters
) -> <ParseCharError as Arbitrary>::Strategy
impl Arbitrary for EscapeDebug
[src]
type Parameters = ()
type Strategy = Map<<char as Arbitrary>::Strategy, fn(char) -> EscapeDebug>
fn arbitrary_with(
_args: <EscapeDebug as Arbitrary>::Parameters
) -> <EscapeDebug as Arbitrary>::Strategy
[src]
_args: <EscapeDebug as Arbitrary>::Parameters
) -> <EscapeDebug as Arbitrary>::Strategy
impl Arbitrary for u16
[src]
type Parameters = ()
type Strategy = Any
fn arbitrary_with(
_args: <u16 as Arbitrary>::Parameters
) -> <u16 as Arbitrary>::Strategy
[src]
_args: <u16 as Arbitrary>::Parameters
) -> <u16 as Arbitrary>::Strategy
impl<A> Arbitrary for UnsafeCell<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = MapInto<<A as Arbitrary>::Strategy, UnsafeCell<A>>
fn arbitrary_with(
args: <UnsafeCell<A> as Arbitrary>::Parameters
) -> <UnsafeCell<A> as Arbitrary>::Strategy
[src]
args: <UnsafeCell<A> as Arbitrary>::Parameters
) -> <UnsafeCell<A> as Arbitrary>::Strategy
impl Arbitrary for Ipv4Addr
[src]
type Parameters = ()
type Strategy = LazyTupleUnion<((u32, Arc<Just<Ipv4Addr>>), (u32, Arc<Just<Ipv4Addr>>), (u32, Arc<MapInto<<u32 as Arbitrary>::Strategy, Ipv4Addr>>))>
fn arbitrary_with(
_args: <Ipv4Addr as Arbitrary>::Parameters
) -> <Ipv4Addr as Arbitrary>::Strategy
[src]
_args: <Ipv4Addr as Arbitrary>::Parameters
) -> <Ipv4Addr as Arbitrary>::Strategy
impl<A> Arbitrary for BinaryHeap<A> where
A: Arbitrary + Ord,
[src]
A: Arbitrary + Ord,
type Parameters = (SizeRange, <A as Arbitrary>::Parameters)
type Strategy = BinaryHeapStrategy<<A as Arbitrary>::Strategy>
fn arbitrary_with(
args: <BinaryHeap<A> as Arbitrary>::Parameters
) -> <BinaryHeap<A> as Arbitrary>::Strategy
[src]
args: <BinaryHeap<A> as Arbitrary>::Parameters
) -> <BinaryHeap<A> as Arbitrary>::Strategy
Implementors
impl Arbitrary for SizeRange
[src]
type Parameters = ()
type Strategy = MapInto<<RangeInclusive<usize> as Arbitrary>::Strategy, SizeRange>
fn arbitrary_with(
_args: <SizeRange as Arbitrary>::Parameters
) -> <SizeRange as Arbitrary>::Strategy
[src]
_args: <SizeRange as Arbitrary>::Parameters
) -> <SizeRange as Arbitrary>::Strategy
impl Arbitrary for Probability
[src]
type Parameters = ()
type Strategy = MapInto<RangeInclusive<f64>, Probability>
fn arbitrary_with(
_args: <Probability as Arbitrary>::Parameters
) -> <Probability as Arbitrary>::Strategy
[src]
_args: <Probability as Arbitrary>::Parameters
) -> <Probability as Arbitrary>::Strategy
impl Arbitrary for Index
[src]
impl Arbitrary for Selector
[src]
impl Arbitrary for RangeFull
[src]
type Parameters = ()
type Strategy = Just<RangeFull>
fn arbitrary_with(
_args: <RangeFull as Arbitrary>::Parameters
) -> <RangeFull as Arbitrary>::Strategy
[src]
_args: <RangeFull as Arbitrary>::Parameters
) -> <RangeFull as Arbitrary>::Strategy
impl<A> Arbitrary for Bound<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = LazyTupleUnion<((u32, Arc<Map<Arc<<A as Arbitrary>::Strategy>, fn(<Arc<<A as Arbitrary>::Strategy> as Strategy>::Value) -> Bound<A>>>), (u32, Arc<Map<Arc<<A as Arbitrary>::Strategy>, fn(<Arc<<A as Arbitrary>::Strategy> as Strategy>::Value) -> Bound<A>>>), (u32, Arc<LazyJust<Bound<A>, fn() -> Bound<A>>>))>
fn arbitrary_with(
args: <Bound<A> as Arbitrary>::Parameters
) -> <Bound<A> as Arbitrary>::Strategy
[src]
args: <Bound<A> as Arbitrary>::Parameters
) -> <Bound<A> as Arbitrary>::Strategy
impl<A> Arbitrary for Range<A> where
A: Arbitrary + PartialOrd<A>,
[src]
A: Arbitrary + PartialOrd<A>,
type Parameters = (<A as Arbitrary>::Parameters, <A as Arbitrary>::Parameters)
type Strategy = Map<<(A, A) as Arbitrary>::Strategy, fn((A, A)) -> Range<A>>
ⓘImportant traits for Range<A>fn arbitrary_with(
args: <Range<A> as Arbitrary>::Parameters
) -> <Range<A> as Arbitrary>::Strategy
[src]
args: <Range<A> as Arbitrary>::Parameters
) -> <Range<A> as Arbitrary>::Strategy
impl<A> Arbitrary for RangeFrom<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> RangeFrom<A>>
ⓘImportant traits for RangeFrom<A>fn arbitrary_with(
args: <RangeFrom<A> as Arbitrary>::Parameters
) -> <RangeFrom<A> as Arbitrary>::Strategy
[src]
args: <RangeFrom<A> as Arbitrary>::Parameters
) -> <RangeFrom<A> as Arbitrary>::Strategy
impl<A> Arbitrary for RangeInclusive<A> where
A: Arbitrary + PartialOrd<A>,
[src]
A: Arbitrary + PartialOrd<A>,
type Parameters = (<A as Arbitrary>::Parameters, <A as Arbitrary>::Parameters)
type Strategy = Map<<(A, A) as Arbitrary>::Strategy, fn((A, A)) -> RangeInclusive<A>>
ⓘImportant traits for RangeInclusive<A>fn arbitrary_with(
args: <RangeInclusive<A> as Arbitrary>::Parameters
) -> <RangeInclusive<A> as Arbitrary>::Strategy
[src]
args: <RangeInclusive<A> as Arbitrary>::Parameters
) -> <RangeInclusive<A> as Arbitrary>::Strategy
impl<A> Arbitrary for RangeTo<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> RangeTo<A>>
fn arbitrary_with(
args: <RangeTo<A> as Arbitrary>::Parameters
) -> <RangeTo<A> as Arbitrary>::Strategy
[src]
args: <RangeTo<A> as Arbitrary>::Parameters
) -> <RangeTo<A> as Arbitrary>::Strategy
impl<A> Arbitrary for RangeToInclusive<A> where
A: Arbitrary,
[src]
A: Arbitrary,
type Parameters = <A as Arbitrary>::Parameters
type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> RangeToInclusive<A>>
fn arbitrary_with(
args: <RangeToInclusive<A> as Arbitrary>::Parameters
) -> <RangeToInclusive<A> as Arbitrary>::Strategy
[src]
args: <RangeToInclusive<A> as Arbitrary>::Parameters
) -> <RangeToInclusive<A> as Arbitrary>::Strategy