Trait proptest::prelude::Arbitrary[][src]

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

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

Arbitrary determines a canonical Strategy for the implementing type.

It provides the 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[src]

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

type Strategy: Strategy<Value = Self>[src]

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

Loading content...

Required methods

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy[src]

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[src]

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 EscapeDefault[src]

type Parameters = ()

type Strategy = SMapped<u8, Self>

impl<A: Arbitrary + Copy> Arbitrary for Cell<A>[src]

type Parameters = A::Parameters

type Strategy = MapInto<A::Strategy, Self>

impl<A: Arbitrary> Arbitrary for RefCell<A>[src]

type Parameters = A::Parameters

type Strategy = MapInto<A::Strategy, Self>

impl<A: Arbitrary> Arbitrary for UnsafeCell<A>[src]

type Parameters = A::Parameters

type Strategy = MapInto<A::Strategy, Self>

impl Arbitrary for BorrowError[src]

type Parameters = ()

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

impl Arbitrary for BorrowMutError[src]

type Parameters = ()

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

impl<A: Arbitrary> Arbitrary for Reverse<A>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl Arbitrary for Ordering[src]

type Parameters = ()

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

impl Arbitrary for Error[src]

type Parameters = ()

type Strategy = Just<Self>

impl<A: Arbitrary> Arbitrary for Once<A>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl<A: Arbitrary + Clone> Arbitrary for Repeat<A>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl<A: Arbitrary + Iterator + Clone> Arbitrary for Cycle<A>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl<A: Arbitrary + Iterator> Arbitrary for Enumerate<A>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl<A: Arbitrary + Iterator> Arbitrary for Fuse<A>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl<A: Arbitrary + Iterator<Item = T>, T: Debug> Arbitrary for Peekable<A>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl<A: Arbitrary + DoubleEndedIterator> Arbitrary for Rev<A>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

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

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl<A> Arbitrary for Empty<A>[src]

type Parameters = ()

type Strategy = Just<Self>

impl<A: Arbitrary + Iterator, B: Arbitrary + Iterator> Arbitrary for Zip<A, B>[src]

type Parameters = (A::Parameters, B::Parameters)

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

impl<T, A: Arbitrary + Iterator<Item = T>, B: Arbitrary + Iterator<Item = T>> Arbitrary for Chain<A, B>[src]

type Parameters = (A::Parameters, B::Parameters)

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

impl<A: Arbitrary + Iterator> Arbitrary for Skip<A>[src]

type Parameters = A::Parameters

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

impl<A: Arbitrary + Iterator> Arbitrary for Take<A>[src]

type Parameters = A::Parameters

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

impl<A: Arbitrary + Iterator> Arbitrary for StepBy<A>[src]

type Parameters = A::Parameters

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

impl<T: ?Sized> Arbitrary for PhantomData<T>[src]

type Parameters = ()

type Strategy = Just<Self>

impl<A: Arbitrary> Arbitrary for Discriminant<A>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl Arbitrary for ParseFloatError[src]

type Parameters = ()

type Strategy = Just<Self>

impl Arbitrary for ParseIntError[src]

type Parameters = ()

type Strategy = Just<Self>

impl Arbitrary for TryFromIntError[src]

type Parameters = ()

type Strategy = Just<Self>

impl<A: Arbitrary> Arbitrary for Wrapping<A>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl Arbitrary for FpCategory[src]

type Parameters = ()

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

impl Arbitrary for Option<ParseError>[src]

type Parameters = ()

type Strategy = Just<Self>

impl Arbitrary for Option<!>[src]

type Parameters = ()

type Strategy = Just<Self>

impl<A: Arbitrary> Arbitrary for Option<A>[src]

type Parameters = (Probability, A::Parameters)

type Strategy = OptionStrategy<A::Strategy>

impl<A: Arbitrary> Arbitrary for IntoIter<A>[src]

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

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

impl Arbitrary for NoneError[src]

type Parameters = ()

type Strategy = Just<Self>

impl<A: Arbitrary> Arbitrary for Result<A, ParseError>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl<A: Arbitrary> Arbitrary for Result<ParseError, A>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl<A: Arbitrary> Arbitrary for Result<A, !>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl<A: Arbitrary> Arbitrary for Result<!, A>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl<A: Arbitrary, B: Arbitrary> Arbitrary for Result<A, B>[src]

type Parameters = (Probability, A::Parameters, B::Parameters)

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

impl<A: Arbitrary> Arbitrary for IntoIter<A>[src]

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

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

impl Arbitrary for Global[src]

type Parameters = ()

type Strategy = Just<Self>

impl Arbitrary for Layout[src]

type Parameters = ()

type Strategy = Map<(Range<u8>, StrategyFor<usize>), fn(_: <(Range<u8>, StrategyFor<usize>) as Strategy>::Value) -> Self>

impl Arbitrary for AllocError[src]

type Parameters = ()

type Strategy = Just<Self>

impl<A: Arbitrary + Borrow<B>, B: ToOwned<Owned = A> + Debug + ?Sized> Arbitrary for Cow<'static, B>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl<A: Arbitrary> Arbitrary for Box<A>[src]

type Parameters = A::Parameters

type Strategy = MapInto<A::Strategy, Self>

impl Arbitrary for EscapeDebug[src]

type Parameters = ()

type Strategy = SMapped<char, Self>

impl Arbitrary for EscapeDefault[src]

type Parameters = ()

type Strategy = SMapped<char, Self>

impl Arbitrary for EscapeUnicode[src]

type Parameters = ()

type Strategy = SMapped<char, Self>

impl Arbitrary for ToLowercase[src]

type Parameters = ()

type Strategy = SMapped<char, Self>

impl Arbitrary for ToUppercase[src]

type Parameters = ()

type Strategy = SMapped<char, Self>

impl Arbitrary for ParseCharError[src]

type Parameters = ()

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

impl Arbitrary for CharTryFromError[src]

type Parameters = ()

type Strategy = Just<Self>

impl Arbitrary for DecodeUtf16Error[src]

type Parameters = ()

type Strategy = Map<Range<u16>, fn(_: <Range<u16> as Strategy>::Value) -> Self>

impl<A: Arbitrary> Arbitrary for Vec<A>[src]

type Parameters = (SizeRange, A::Parameters)

type Strategy = VecStrategy<A::Strategy>

impl<A: Arbitrary> Arbitrary for Box<[A]>[src]

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

type Strategy = MapInto<StrategyFor<Vec<A>>, Self>

impl<A: Arbitrary> Arbitrary for Rc<[A]>[src]

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

type Strategy = MapInto<StrategyFor<Vec<A>>, Self>

impl<A: Arbitrary> Arbitrary for Arc<[A]>[src]

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

type Strategy = MapInto<StrategyFor<Vec<A>>, Self>

impl<A: Arbitrary> Arbitrary for VecDeque<A>[src]

type Parameters = (SizeRange, A::Parameters)

type Strategy = VecDequeStrategy<A::Strategy>

impl<A: Arbitrary> Arbitrary for LinkedList<A>[src]

type Parameters = (SizeRange, A::Parameters)

type Strategy = LinkedListStrategy<A::Strategy>

impl<A: Arbitrary + Ord> Arbitrary for BTreeSet<A>[src]

type Parameters = (SizeRange, A::Parameters)

type Strategy = BTreeSetStrategy<A::Strategy>

impl<A: Arbitrary + Ord> Arbitrary for BinaryHeap<A>[src]

type Parameters = (SizeRange, A::Parameters)

type Strategy = BinaryHeapStrategy<A::Strategy>

impl<A: Arbitrary> Arbitrary for IntoIter<A>[src]

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

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

impl<A: Arbitrary> Arbitrary for IntoIter<A>[src]

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

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

impl<A: Arbitrary> Arbitrary for IntoIter<A>[src]

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

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

impl<A: Arbitrary + Ord> Arbitrary for IntoIter<A>[src]

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

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

impl<A: Arbitrary + Ord> Arbitrary for IntoIter<A>[src]

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

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

impl<A: Arbitrary + Ord, B: Arbitrary> Arbitrary for BTreeMap<A, B>[src]

type Parameters = (SizeRange, A::Parameters, B::Parameters)

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

impl<A: Arbitrary + Ord, B: Arbitrary> Arbitrary for IntoIter<A, B>[src]

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

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

impl<A: Arbitrary> Arbitrary for Bound<A>[src]

type Parameters = A::Parameters

type Strategy = TupleUnion<(WA<Map<Arc<A::Strategy>, fn(_: <Arc<A::Strategy> as Strategy>::Value) -> Self>>, WA<Map<Arc<A::Strategy>, fn(_: <Arc<A::Strategy> as Strategy>::Value) -> Self>>, WA<LazyJustFn<Self>>)>

impl<H: Default + Hasher> Arbitrary for BuildHasherDefault<H>[src]

type Parameters = ()

type Strategy = Just<Self>

impl Arbitrary for RangeFull[src]

type Parameters = ()

type Strategy = Just<Self>

impl<A: Arbitrary> Arbitrary for RangeFrom<A>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl<A: Arbitrary> Arbitrary for RangeTo<A>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl<A: Arbitrary> Arbitrary for RangeToInclusive<A>[src]

type Parameters = A::Parameters

type Strategy = SMapped<A, Self>

impl<A: PartialOrd + Arbitrary> Arbitrary for RangeInclusive<A>[src]

type Parameters = (A::Parameters, A::Parameters)

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

impl<A: PartialOrd + Arbitrary> Arbitrary for Range<A>[src]

type Parameters = (A::Parameters, A::Parameters)

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

impl<Y: Arbitrary, R: Arbitrary> Arbitrary for GeneratorState<Y, R>[src]

type Parameters = (Y::Parameters, R::Parameters)

type Strategy = TupleUnion<(WA<SMapped<Y, Self>>, WA<SMapped<R, Self>>)>

impl<A: Arbitrary> Arbitrary for Rc<A>[src]

type Parameters = A::Parameters

type Strategy = MapInto<A::Strategy, Self>

impl Arbitrary for ParseBoolError[src]

type Parameters = ()

type Strategy = Just<Self>

impl Arbitrary for Utf8Error[src]

type Parameters = ()

type Strategy = Map<(StrategyFor<u16>, TupleUnion<(WA<Just<&'static [u8]>>, WA<Just<&'static [u8]>>, WA<Just<&'static [u8]>>, WA<Just<&'static [u8]>>)>), fn(_: <(StrategyFor<u16>, TupleUnion<(WA<Just<&'static [u8]>>, WA<Just<&'static [u8]>>, WA<Just<&'static [u8]>>, WA<Just<&'static [u8]>>)>) as Strategy>::Value) -> Utf8Error>

impl<A: Arbitrary> Arbitrary for Arc<A>[src]

type Parameters = A::Parameters

type Strategy = MapInto<A::Strategy, Self>

impl Arbitrary for AtomicBool[src]

type Parameters = ()

type Strategy = SMapped<bool, Self>

impl Arbitrary for AtomicIsize[src]

type Parameters = ()

type Strategy = SMapped<isize, Self>

impl Arbitrary for AtomicUsize[src]

type Parameters = ()

type Strategy = SMapped<usize, Self>

impl Arbitrary for AtomicI8[src]

type Parameters = ()

type Strategy = SMapped<i8, Self>

impl Arbitrary for AtomicI16[src]

type Parameters = ()

type Strategy = SMapped<i16, Self>

impl Arbitrary for AtomicI32[src]

type Parameters = ()

type Strategy = SMapped<i32, Self>

impl Arbitrary for AtomicU8[src]

type Parameters = ()

type Strategy = SMapped<u8, Self>

impl Arbitrary for AtomicU16[src]

type Parameters = ()

type Strategy = SMapped<u16, Self>

impl Arbitrary for AtomicU32[src]

type Parameters = ()

type Strategy = SMapped<u32, Self>

impl Arbitrary for Ordering[src]

type Parameters = ()

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

Loading content...

Implementors

impl Arbitrary for ()[src]

type Parameters = ()

type Strategy = Just<Self>

impl Arbitrary for SizeRange[src]

type Parameters = ()

type Strategy = MapInto<StrategyFor<RangeInclusive<usize>>, Self>

impl Arbitrary for Probability[src]

type Parameters = ()

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

impl Arbitrary for Index[src]

impl Arbitrary for Selector[src]

impl Arbitrary for bool[src]

type Parameters = ()

type Strategy = Any

impl Arbitrary for char[src]

type Parameters = ()

type Strategy = CharStrategy<'static>

impl Arbitrary for f32[src]

type Parameters = ()

type Strategy = Any

impl Arbitrary for f64[src]

type Parameters = ()

type Strategy = Any

impl Arbitrary for i8[src]

type Parameters = ()

type Strategy = Any

impl Arbitrary for i16[src]

type Parameters = ()

type Strategy = Any

impl Arbitrary for i32[src]

type Parameters = ()

type Strategy = Any

impl Arbitrary for i64[src]

type Parameters = ()

type Strategy = Any

impl Arbitrary for i128[src]

type Parameters = ()

type Strategy = Any

impl Arbitrary for isize[src]

type Parameters = ()

type Strategy = Any

impl Arbitrary for u8[src]

type Parameters = ()

type Strategy = Any

impl Arbitrary for u16[src]

type Parameters = ()

type Strategy = Any

impl Arbitrary for u32[src]

type Parameters = ()

type Strategy = Any

impl Arbitrary for u64[src]

type Parameters = ()

type Strategy = Any

impl Arbitrary for u128[src]

type Parameters = ()

type Strategy = Any

impl Arbitrary for usize[src]

type Parameters = ()

type Strategy = Any

impl<A: Arbitrary> Arbitrary for [A; 1][src]

impl<A: Arbitrary> Arbitrary for [A; 2][src]

impl<A: Arbitrary> Arbitrary for [A; 3][src]

impl<A: Arbitrary> Arbitrary for [A; 4][src]

impl<A: Arbitrary> Arbitrary for [A; 5][src]

impl<A: Arbitrary> Arbitrary for [A; 6][src]

impl<A: Arbitrary> Arbitrary for [A; 7][src]

impl<A: Arbitrary> Arbitrary for [A; 8][src]

impl<A: Arbitrary> Arbitrary for [A; 9][src]

impl<A: Arbitrary> Arbitrary for [A; 10][src]

impl<A: Arbitrary> Arbitrary for [A; 11][src]

impl<A: Arbitrary> Arbitrary for [A; 12][src]

impl<A: Arbitrary> Arbitrary for [A; 13][src]

impl<A: Arbitrary> Arbitrary for [A; 14][src]

impl<A: Arbitrary> Arbitrary for [A; 15][src]

impl<A: Arbitrary> Arbitrary for [A; 16][src]

impl<A: Arbitrary> Arbitrary for [A; 17][src]

impl<A: Arbitrary> Arbitrary for [A; 18][src]

impl<A: Arbitrary> Arbitrary for [A; 19][src]

impl<A: Arbitrary> Arbitrary for [A; 20][src]

impl<A: Arbitrary> Arbitrary for [A; 21][src]

impl<A: Arbitrary> Arbitrary for [A; 22][src]

impl<A: Arbitrary> Arbitrary for [A; 23][src]

impl<A: Arbitrary> Arbitrary for [A; 24][src]

impl<A: Arbitrary> Arbitrary for [A; 25][src]

impl<A: Arbitrary> Arbitrary for [A; 26][src]

impl<A: Arbitrary> Arbitrary for [A; 27][src]

impl<A: Arbitrary> Arbitrary for [A; 28][src]

impl<A: Arbitrary> Arbitrary for [A; 29][src]

impl<A: Arbitrary> Arbitrary for [A; 30][src]

impl<A: Arbitrary> Arbitrary for [A; 31][src]

impl<A: Arbitrary> Arbitrary for [A; 32][src]

impl<T0: Arbitrary> Arbitrary for (T0,)[src]

type Parameters = (T0::Parameters,)

type Strategy = (T0::Strategy,)

impl<T0: Arbitrary, T1: Arbitrary> Arbitrary for (T0, T1)[src]

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

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

impl<T0: Arbitrary, T1: Arbitrary, T2: Arbitrary> Arbitrary for (T0, T1, T2)[src]

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

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

impl<T0: Arbitrary, T1: Arbitrary, T2: Arbitrary, T3: Arbitrary> Arbitrary for (T0, T1, T2, T3)[src]

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

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

impl<T0: Arbitrary, T1: Arbitrary, T2: Arbitrary, T3: Arbitrary, T4: Arbitrary> Arbitrary for (T0, T1, T2, T3, T4)[src]

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

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

impl<T0: Arbitrary, T1: Arbitrary, T2: Arbitrary, T3: Arbitrary, T4: Arbitrary, T5: Arbitrary> Arbitrary for (T0, T1, T2, T3, T4, T5)[src]

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

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

impl<T0: Arbitrary, T1: Arbitrary, T2: Arbitrary, T3: Arbitrary, T4: Arbitrary, T5: Arbitrary, T6: Arbitrary> Arbitrary for (T0, T1, T2, T3, T4, T5, T6)[src]

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

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

impl<T0: Arbitrary, T1: Arbitrary, T2: Arbitrary, T3: Arbitrary, T4: Arbitrary, T5: Arbitrary, T6: Arbitrary, T7: Arbitrary> Arbitrary for (T0, T1, T2, T3, T4, T5, T6, T7)[src]

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

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

impl<T0: Arbitrary, T1: Arbitrary, T2: Arbitrary, T3: Arbitrary, T4: Arbitrary, T5: Arbitrary, T6: Arbitrary, T7: Arbitrary, T8: Arbitrary> Arbitrary for (T0, T1, T2, T3, T4, T5, T6, T7, T8)[src]

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

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

impl<T0: Arbitrary, T1: Arbitrary, T2: Arbitrary, T3: Arbitrary, T4: Arbitrary, T5: Arbitrary, T6: Arbitrary, T7: Arbitrary, T8: Arbitrary, T9: Arbitrary> Arbitrary for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)[src]

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

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

Loading content...