Trait un_algebra::tests::config::prop::arbitrary::Arbitrary

pub trait Arbitrary: Debug where
    <Self::Strategy as Strategy>::Value == Self, {
    type Parameters: Default;
    type Strategy: Strategy;
    fn arbitrary_with(args: Self::Parameters) -> Self::Strategy;

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

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 Strategys 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.

Loading content...

Required methods

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

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

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

Loading content...

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.

Loading content...

Implementations on Foreign Types

impl Arbitrary for f64

type Parameters = ()

type Strategy = Any

fn arbitrary_with(
    _args: <f64 as Arbitrary>::Parameters
) -> <f64 as Arbitrary>::Strategy

impl Arbitrary for f32

type Parameters = ()

type Strategy = Any

fn arbitrary_with(
    _args: <f32 as Arbitrary>::Parameters
) -> <f32 as Arbitrary>::Strategy

impl<A> Arbitrary for [A; 21] where
    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

impl Arbitrary for FpCategory

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

impl<A> Arbitrary for Result<A, !> where
    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

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, 

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

impl<A> Arbitrary for Box<A> where
    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

impl Arbitrary for BorrowError

type Parameters = ()

type Strategy = LazyJust<BorrowError, fn() -> BorrowError>

fn arbitrary_with(
    _args: <BorrowError as Arbitrary>::Parameters
) -> <BorrowError as Arbitrary>::Strategy

impl<A> Arbitrary for LineWriter<A> where
    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

impl<A> Arbitrary for [A; 15] where
    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

impl<A, B> Arbitrary for Chain<A, B> where
    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

impl Arbitrary for i16

type Parameters = ()

type Strategy = Any

fn arbitrary_with(
    _args: <i16 as Arbitrary>::Parameters
) -> <i16 as Arbitrary>::Strategy

impl Arbitrary for u16

type Parameters = ()

type Strategy = Any

fn arbitrary_with(
    _args: <u16 as Arbitrary>::Parameters
) -> <u16 as Arbitrary>::Strategy

impl Arbitrary for Once

type Parameters = ()

type Strategy = LazyJust<Once, fn() -> Once>

fn arbitrary_with(
    _args: <Once as Arbitrary>::Parameters
) -> <Once as Arbitrary>::Strategy

impl Arbitrary for Stderr

type Parameters = ()

type Strategy = LazyJust<Stderr, fn() -> Stderr>

fn arbitrary_with(
    _args: <Stderr as Arbitrary>::Parameters
) -> <Stderr as Arbitrary>::Strategy

impl<A> Arbitrary for [A; 23] where
    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

impl Arbitrary for Barrier

type Parameters = ()

type Strategy = Map<<u16 as Arbitrary>::Strategy, fn(u16) -> Barrier>

fn arbitrary_with(
    _args: <Barrier as Arbitrary>::Parameters
) -> <Barrier as Arbitrary>::Strategy

impl<A> Arbitrary for IntoIter<A> where
    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

impl<A> Arbitrary for [A; 9] where
    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

impl<A> Arbitrary for Rc<A> where
    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

impl<A> Arbitrary for Repeat<A> where
    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

impl<A> Arbitrary for Option<A> where
    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

impl<A> Arbitrary for HashSet<A, RandomState> where
    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

impl<A, B> Arbitrary for Result<A, B> where
    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

impl Arbitrary for AtomicUsize

type Parameters = ()

type Strategy = Map<<usize as Arbitrary>::Strategy, fn(usize) -> AtomicUsize>

fn arbitrary_with(
    _args: <AtomicUsize as Arbitrary>::Parameters
) -> <AtomicUsize as Arbitrary>::Strategy

impl Arbitrary for Box<CStr>

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

impl<A> Arbitrary for [A; 14] where
    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

impl Arbitrary for i8

type Parameters = ()

type Strategy = Any

fn arbitrary_with(
    _args: <i8 as Arbitrary>::Parameters
) -> <i8 as Arbitrary>::Strategy

impl Arbitrary for SocketAddr

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

impl Arbitrary for Empty

type Parameters = ()

type Strategy = LazyJust<Empty, fn() -> Empty>

fn arbitrary_with(
    _args: <Empty as Arbitrary>::Parameters
) -> <Empty as Arbitrary>::Strategy

impl Arbitrary for Box<OsStr>

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

impl Arbitrary for Box<str>

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

impl<A> Arbitrary for [A; 25] where
    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

impl Arbitrary for u32

type Parameters = ()

type Strategy = Any

fn arbitrary_with(
    _args: <u32 as Arbitrary>::Parameters
) -> <u32 as Arbitrary>::Strategy

impl<A, T> Arbitrary for Peekable<A> where
    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

impl Arbitrary for RandomState

type Parameters = ()

type Strategy = LazyJust<RandomState, fn() -> RandomState>

fn arbitrary_with(
    _args: <RandomState as Arbitrary>::Parameters
) -> <RandomState as Arbitrary>::Strategy

impl<A> Arbitrary for Cycle<A> where
    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

impl Arbitrary for FromUtf16Error

type Parameters = ()

type Strategy = LazyJust<FromUtf16Error, fn() -> FromUtf16Error>

fn arbitrary_with(
    _args: <FromUtf16Error as Arbitrary>::Parameters
) -> <FromUtf16Error as Arbitrary>::Strategy

impl<A> Arbitrary for [A; 3] where
    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

impl<A> Arbitrary for [A; 13] where
    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

impl<A> Arbitrary for Vec<A> where
    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

impl<A> Arbitrary for VecDeque<A> where
    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

impl<A> Arbitrary for Empty<A>

type Parameters = ()

type Strategy = Just<Empty<A>>

fn arbitrary_with(
    _args: <Empty<A> as Arbitrary>::Parameters
) -> <Empty<A> as Arbitrary>::Strategy

impl<A> Arbitrary for [A; 32] where
    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

impl Arbitrary for Repeat

type Parameters = ()

type Strategy = Map<<u8 as Arbitrary>::Strategy, fn(u8) -> Repeat>

fn arbitrary_with(
    _args: <Repeat as Arbitrary>::Parameters
) -> <Repeat as Arbitrary>::Strategy

impl Arbitrary for ParseFloatError

type Parameters = ()

type Strategy = Just<ParseFloatError>

fn arbitrary_with(
    _args: <ParseFloatError as Arbitrary>::Parameters
) -> <ParseFloatError as Arbitrary>::Strategy

impl<A> Arbitrary for [A; 28] where
    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

impl Arbitrary for Ordering

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

impl Arbitrary for ParseCharError

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

impl<T0, T1, T2> Arbitrary for (T0, T1, T2) where
    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

impl<A> Arbitrary for Reverse<A> where
    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

impl<A> Arbitrary for IntoIter<A> where
    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

impl<T0> Arbitrary for (T0,) where
    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

impl Arbitrary for Instant

type Parameters = ()

type Strategy = Just<Instant>

fn arbitrary_with(
    _args: <Instant as Arbitrary>::Parameters
) -> <Instant as Arbitrary>::Strategy

impl<A> Arbitrary for Enumerate<A> where
    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

impl<T> Arbitrary for PhantomData<T> where
    T: ?Sized, 

type Parameters = ()

type Strategy = Just<PhantomData<T>>

fn arbitrary_with(
    _args: <PhantomData<T> as Arbitrary>::Parameters
) -> <PhantomData<T> as Arbitrary>::Strategy

impl Arbitrary for u64

type Parameters = ()

type Strategy = Any

fn arbitrary_with(
    _args: <u64 as Arbitrary>::Parameters
) -> <u64 as Arbitrary>::Strategy

impl Arbitrary for Error

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

impl Arbitrary for SeekFrom

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

impl<A> Arbitrary for Lines<A> where
    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

impl<A> Arbitrary for [A; 19] where
    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

impl<A> Arbitrary for Rc<[A]> where
    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

impl<A> Arbitrary for [A; 7] where
    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

impl<A> Arbitrary for RwLock<A> where
    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

impl<A> Arbitrary for [A; 29] where
    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

impl Arbitrary for u8

type Parameters = ()

type Strategy = Any

fn arbitrary_with(
    _args: <u8 as Arbitrary>::Parameters
) -> <u8 as Arbitrary>::Strategy

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

type Parameters = ()

type Strategy = Just<BuildHasherDefault<H>>

fn arbitrary_with(
    _args: <BuildHasherDefault<H> as Arbitrary>::Parameters
) -> <BuildHasherDefault<H> as Arbitrary>::Strategy

impl Arbitrary for IntoStringError

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

impl<A> Arbitrary for [A; 16] where
    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

impl Arbitrary for Condvar

type Parameters = ()

type Strategy = LazyJust<Condvar, fn() -> Condvar>

fn arbitrary_with(
    _args: <Condvar as Arbitrary>::Parameters
) -> <Condvar as Arbitrary>::Strategy

impl Arbitrary for DefaultHasher

type Parameters = ()

type Strategy = LazyJust<DefaultHasher, fn() -> DefaultHasher>

fn arbitrary_with(
    _args: <DefaultHasher as Arbitrary>::Parameters
) -> <DefaultHasher as Arbitrary>::Strategy

impl Arbitrary for BarrierWaitResult

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

impl<A> Arbitrary for [A; 20] where
    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

impl Arbitrary for Stdin

type Parameters = ()

type Strategy = LazyJust<Stdin, fn() -> Stdin>

fn arbitrary_with(
    _args: <Stdin as Arbitrary>::Parameters
) -> <Stdin as Arbitrary>::Strategy

impl Arbitrary for AtomicIsize

type Parameters = ()

type Strategy = Map<<isize as Arbitrary>::Strategy, fn(isize) -> AtomicIsize>

fn arbitrary_with(
    _args: <AtomicIsize as Arbitrary>::Parameters
) -> <AtomicIsize as Arbitrary>::Strategy

impl<A> Arbitrary for [A; 2] where
    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

impl<A> Arbitrary for Once<A> where
    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

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

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

impl<A, B> Arbitrary for IntoIter<A, B> where
    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

impl<A> Arbitrary for Take<A> where
    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

impl<A> Arbitrary for Arc<[A]> where
    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

impl<A> Arbitrary for (SyncSender<A>, IntoIter<A>) where
    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

impl Arbitrary for SocketAddrV4

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

impl Arbitrary for DecodeUtf16Error

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

impl Arbitrary for Arc<str>

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

impl Arbitrary for Option<!>

type Parameters = ()

type Strategy = Just<Option<!>>

fn arbitrary_with(
    _args: <Option<!> as Arbitrary>::Parameters
) -> <Option<!> as Arbitrary>::Strategy

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

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

impl<A> Arbitrary for Box<[A]> where
    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

impl<A> Arbitrary for AssertUnwindSafe<A> where
    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

impl Arbitrary for u128

type Parameters = ()

type Strategy = Any

fn arbitrary_with(
    _args: <u128 as Arbitrary>::Parameters
) -> <u128 as Arbitrary>::Strategy

impl<A> Arbitrary for Mutex<A> where
    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

impl Arbitrary for ArgsOs

type Parameters = ()

type Strategy = LazyJust<ArgsOs, fn() -> ArgsOs>

fn arbitrary_with(
    _args: <ArgsOs as Arbitrary>::Parameters
) -> <ArgsOs as Arbitrary>::Strategy

impl Arbitrary for FromBytesWithNulError

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

impl Arbitrary for EscapeDefault

type Parameters = ()

type Strategy = Map<<char as Arbitrary>::Strategy, fn(char) -> EscapeDefault>

fn arbitrary_with(
    _args: <EscapeDefault as Arbitrary>::Parameters
) -> <EscapeDefault as Arbitrary>::Strategy

impl Arbitrary for String

type Parameters = StringParam

type Strategy = &'static str

fn arbitrary_with(
    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<A, B> Arbitrary for BTreeMap<A, B> where
    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

impl<A> Arbitrary for Take<A> where
    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

impl Arbitrary for Rc<str>

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

impl<A> Arbitrary for [A; 5] where
    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

impl<A> Arbitrary for Rev<A> where
    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

impl<A, B> Arbitrary for IntoIter<A, B> where
    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

impl<A> Arbitrary for [A; 18] where
    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

impl<A, B> Arbitrary for Zip<A, B> where
    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

impl Arbitrary for Args

type Parameters = ()

type Strategy = LazyJust<Args, fn() -> Args>

fn arbitrary_with(
    _args: <Args as Arbitrary>::Parameters
) -> <Args as Arbitrary>::Strategy

impl<A> Arbitrary for UnsafeCell<A> where
    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

impl<A> Arbitrary for BufWriter<A> where
    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

impl<A> Arbitrary for [A; 24] where
    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

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, 

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

impl Arbitrary for i128

type Parameters = ()

type Strategy = Any

fn arbitrary_with(
    _args: <i128 as Arbitrary>::Parameters
) -> <i128 as Arbitrary>::Strategy

impl<A> Arbitrary for Skip<A> where
    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

impl Arbitrary for EscapeDebug

type Parameters = ()

type Strategy = Map<<char as Arbitrary>::Strategy, fn(char) -> EscapeDebug>

fn arbitrary_with(
    _args: <EscapeDebug as Arbitrary>::Parameters
) -> <EscapeDebug as Arbitrary>::Strategy

impl<T, A, B> Arbitrary for Chain<A, B> where
    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

impl<A> Arbitrary for [A; 31] where
    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

impl<A> Arbitrary for [A; 22] where
    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

impl Arbitrary for Duration

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

impl<A> Arbitrary for IntoIter<A> where
    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

impl<A> Arbitrary for BTreeSet<A> where
    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

impl Arbitrary for AtomicBool

type Parameters = ()

type Strategy = Map<<bool as Arbitrary>::Strategy, fn(bool) -> AtomicBool>

fn arbitrary_with(
    _args: <AtomicBool as Arbitrary>::Parameters
) -> <AtomicBool as Arbitrary>::Strategy

impl<A> Arbitrary for [A; 26] where
    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

impl Arbitrary for DecodeUtf16<<Vec<u16> as IntoIterator>::IntoIter>

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

impl Arbitrary for Utf8Error

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

impl<A> Arbitrary for Wrapping<A> where
    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

impl Arbitrary for bool

type Parameters = ()

type Strategy = Any

fn arbitrary_with(
    _args: <bool as Arbitrary>::Parameters
) -> <bool as Arbitrary>::Strategy

impl Arbitrary for RecvTimeoutError

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

impl Arbitrary for VarError

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

impl<A> Arbitrary for [A; 12] where
    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

impl<A, B> Arbitrary for HashMap<A, B, RandomState> where
    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

impl<A> Arbitrary for Fuse<A> where
    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

impl Arbitrary for JoinPathsError

type Parameters = ()

type Strategy = LazyJust<JoinPathsError, fn() -> JoinPathsError>

fn arbitrary_with(
    _args: <JoinPathsError as Arbitrary>::Parameters
) -> <JoinPathsError as Arbitrary>::Strategy

impl Arbitrary for Shutdown

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

impl Arbitrary for FromUtf8Error

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

impl<'a, T, A> Arbitrary for Cloned<A> where
    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

impl Arbitrary for isize

type Parameters = ()

type Strategy = Any

fn arbitrary_with(
    _args: <isize as Arbitrary>::Parameters
) -> <isize as Arbitrary>::Strategy

impl Arbitrary for Vars

type Parameters = ()

type Strategy = LazyJust<Vars, fn() -> Vars>

fn arbitrary_with(
    _args: <Vars as Arbitrary>::Parameters
) -> <Vars as Arbitrary>::Strategy

impl Arbitrary for ErrorKind

type Parameters = ()

type Strategy = Union<Just<ErrorKind>>

fn arbitrary_with(
    _args: <ErrorKind as Arbitrary>::Parameters
) -> <ErrorKind as Arbitrary>::Strategy

impl Arbitrary for AddrParseError

type Parameters = ()

type Strategy = Just<AddrParseError>

fn arbitrary_with(
    _args: <AddrParseError as Arbitrary>::Parameters
) -> <AddrParseError as Arbitrary>::Strategy

impl<A> Arbitrary for RefCell<A> where
    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

impl<A> Arbitrary for Result<!, A> where
    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

impl Arbitrary for Ipv4Addr

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

impl<A> Arbitrary for Cursor<A> where
    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

impl Arbitrary for StripPrefixError

type Parameters = ()

type Strategy = Just<StripPrefixError>

fn arbitrary_with(
    _args: <StripPrefixError as Arbitrary>::Parameters
) -> <StripPrefixError as Arbitrary>::Strategy

impl<A> Arbitrary for IntoIter<A> where
    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

impl Arbitrary for Builder

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

impl<A> Arbitrary for IntoIter<A> where
    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

impl<T> Arbitrary for SendError<T> where
    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

impl Arbitrary for WaitTimeoutResult

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

impl<A> Arbitrary for BinaryHeap<A> where
    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

impl Arbitrary for Ipv6Addr

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

impl<A> Arbitrary for Split<A> where
    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

impl Arbitrary for i32

type Parameters = ()

type Strategy = Any

fn arbitrary_with(
    _args: <i32 as Arbitrary>::Parameters
) -> <i32 as Arbitrary>::Strategy

impl Arbitrary for EscapeUnicode

type Parameters = ()

type Strategy = Map<<char as Arbitrary>::Strategy, fn(char) -> EscapeUnicode>

fn arbitrary_with(
    _args: <EscapeUnicode as Arbitrary>::Parameters
) -> <EscapeUnicode as Arbitrary>::Strategy

impl<A> Arbitrary for [A; 4] where
    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

impl<A> Arbitrary for [A; 27] where
    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

impl Arbitrary for EscapeDefault

type Parameters = ()

type Strategy = Map<<u8 as Arbitrary>::Strategy, fn(u8) -> EscapeDefault>

fn arbitrary_with(
    _args: <EscapeDefault as Arbitrary>::Parameters
) -> <EscapeDefault as Arbitrary>::Strategy

impl<A> Arbitrary for [A; 30] where
    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

impl<A> Arbitrary for Discriminant<A> where
    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

impl Arbitrary for OsString

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

impl<A> Arbitrary for LinkedList<A> where
    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

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, 

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

impl Arbitrary for Ordering

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

impl<A> Arbitrary for [A; 6] where
    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

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, 

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

impl<A> Arbitrary for IntoIter<A> where
    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

impl<A> Arbitrary for [A; 11] where
    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

impl<T0, T1> Arbitrary for (T0, T1) where
    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

impl<A, B> Arbitrary for Cow<'static, B> where
    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

impl<T0, T1, T2, T3, T4> Arbitrary for (T0, T1, T2, T3, T4) where
    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

impl Arbitrary for ParseBoolError

type Parameters = ()

type Strategy = Just<ParseBoolError>

fn arbitrary_with(
    _args: <ParseBoolError as Arbitrary>::Parameters
) -> <ParseBoolError as Arbitrary>::Strategy

impl Arbitrary for SocketAddrV6

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

impl Arbitrary for usize

type Parameters = ()

type Strategy = Any

fn arbitrary_with(
    _args: <usize as Arbitrary>::Parameters
) -> <usize as Arbitrary>::Strategy

impl Arbitrary for DirBuilder

type Parameters = ()

type Strategy = Map<<bool as Arbitrary>::Strategy, fn(bool) -> DirBuilder>

fn arbitrary_with(
    _args: <DirBuilder as Arbitrary>::Parameters
) -> <DirBuilder as Arbitrary>::Strategy

impl Arbitrary for char

type Parameters = ()

type Strategy = CharStrategy<'static>

fn arbitrary_with(
    _args: <char as Arbitrary>::Parameters
) -> <char as Arbitrary>::Strategy

impl<A> Arbitrary for (Sender<A>, IntoIter<A>) where
    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

impl<T0, T1, T2, T3> Arbitrary for (T0, T1, T2, T3) where
    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

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, 

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

impl Arbitrary for Sink

type Parameters = ()

type Strategy = LazyJust<Sink, fn() -> Sink>

fn arbitrary_with(
    _args: <Sink as Arbitrary>::Parameters
) -> <Sink as Arbitrary>::Strategy

impl Arbitrary for RecvError

type Parameters = ()

type Strategy = Just<RecvError>

fn arbitrary_with(
    _args: <RecvError as Arbitrary>::Parameters
) -> <RecvError as Arbitrary>::Strategy

impl Arbitrary for ()

type Parameters = ()

type Strategy = Just<()>

fn arbitrary_with(
    _args: <() as Arbitrary>::Parameters
) -> <() as Arbitrary>::Strategy

impl<A> Arbitrary for [A; 10] where
    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

impl Arbitrary for Error

type Parameters = ()

type Strategy = Just<Error>

fn arbitrary_with(
    _args: <Error as Arbitrary>::Parameters
) -> <Error as Arbitrary>::Strategy

impl<A> Arbitrary for [A; 1] where
    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

impl<A> Arbitrary for Arc<A> where
    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

impl Arbitrary for CString

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

impl Arbitrary for Stdout

type Parameters = ()

type Strategy = LazyJust<Stdout, fn() -> Stdout>

fn arbitrary_with(
    _args: <Stdout as Arbitrary>::Parameters
) -> <Stdout as Arbitrary>::Strategy

impl<A> Arbitrary for [A; 17] where
    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

impl<A> Arbitrary for [A; 8] where
    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

impl Arbitrary for i64

type Parameters = ()

type Strategy = Any

fn arbitrary_with(
    _args: <i64 as Arbitrary>::Parameters
) -> <i64 as Arbitrary>::Strategy

impl Arbitrary for ParseIntError

type Parameters = ()

type Strategy = Just<ParseIntError>

fn arbitrary_with(
    _args: <ParseIntError as Arbitrary>::Parameters
) -> <ParseIntError as Arbitrary>::Strategy

impl<A> Arbitrary for IntoIter<A> where
    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

impl Arbitrary for TryRecvError

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

impl<A> Arbitrary for IntoIter<A> where
    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

impl Arbitrary for VarsOs

type Parameters = ()

type Strategy = LazyJust<VarsOs, fn() -> VarsOs>

fn arbitrary_with(
    _args: <VarsOs as Arbitrary>::Parameters
) -> <VarsOs as Arbitrary>::Strategy

impl<A> Arbitrary for BufReader<A> where
    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

impl<P, T> Arbitrary for TrySendError<T> where
    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

impl Arbitrary for BorrowMutError

type Parameters = ()

type Strategy = LazyJust<BorrowMutError, fn() -> BorrowMutError>

fn arbitrary_with(
    _args: <BorrowMutError as Arbitrary>::Parameters
) -> <BorrowMutError as Arbitrary>::Strategy

impl<A> Arbitrary for Cell<A> where
    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

impl Arbitrary for IpAddr

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

impl Arbitrary for SystemTime

type Parameters = ()

type Strategy = Map<(Any, Range<u32>), fn((i32, u32)) -> SystemTime>

fn arbitrary_with(
    _args: <SystemTime as Arbitrary>::Parameters
) -> <SystemTime as Arbitrary>::Strategy

Loading content...

Implementors

impl Arbitrary for SizeRange

type Parameters = ()

type Strategy = MapInto<<RangeInclusive<usize> as Arbitrary>::Strategy, SizeRange>

fn arbitrary_with(
    _args: <SizeRange as Arbitrary>::Parameters
) -> <SizeRange as Arbitrary>::Strategy

impl Arbitrary for Probability

type Parameters = ()

type Strategy = MapInto<RangeInclusive<f64>, Probability>

fn arbitrary_with(
    _args: <Probability as Arbitrary>::Parameters
) -> <Probability as Arbitrary>::Strategy

impl Arbitrary for Index

type Parameters = ()

type Strategy = IndexStrategy

fn arbitrary_with(()) -> IndexStrategy

impl Arbitrary for Selector

type Parameters = ()

type Strategy = SelectorStrategy

fn arbitrary_with(()) -> SelectorStrategy

impl Arbitrary for RangeFull

type Parameters = ()

type Strategy = Just<RangeFull>

fn arbitrary_with(
    _args: <RangeFull as Arbitrary>::Parameters
) -> <RangeFull as Arbitrary>::Strategy

impl<A> Arbitrary for Bound<A> where
    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

impl<A> Arbitrary for Range<A> where
    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>

impl<A> Iterator for Range<A> where
    A: Step,  type Item = A;

fn arbitrary_with(
    args: <Range<A> as Arbitrary>::Parameters
) -> <Range<A> as Arbitrary>::Strategy

impl<A> Arbitrary for RangeFrom<A> where
    A: Arbitrary, 

type Parameters = <A as Arbitrary>::Parameters

type Strategy = Map<<A as Arbitrary>::Strategy, fn(A) -> RangeFrom<A>>

Important traits for RangeFrom<A>

impl<A> Iterator for RangeFrom<A> where
    A: Step,  type Item = A;

fn arbitrary_with(
    args: <RangeFrom<A> as Arbitrary>::Parameters
) -> <RangeFrom<A> as Arbitrary>::Strategy

impl<A> Arbitrary for RangeInclusive<A> where
    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>

impl<A> Iterator for RangeInclusive<A> where
    A: Step,  type Item = A;

fn arbitrary_with(
    args: <RangeInclusive<A> as Arbitrary>::Parameters
) -> <RangeInclusive<A> as Arbitrary>::Strategy

impl<A> Arbitrary for RangeTo<A> where
    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

impl<A> Arbitrary for RangeToInclusive<A> where
    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

Loading content...