Trait proptest::arbitrary::functor::ArbitraryF1

pub trait ArbitraryF1<A: Debug>: Debug + Sized {
type Parameters: Default;
    fn lift1_with<AS>(base: AS, args: Self::Parameters) -> BoxedStrategy<Self>
    where
        AS: Strategy<Value = A> + 'static;

    fn lift1<AS>(base: AS) -> BoxedStrategy<Self>
    where
        AS: Strategy<Value = A> + 'static,
    { ... }
}

ArbitraryF1 lets you lift a Strategy to unary type constructors such as Box, Vec, and Option.

The trait corresponds to Haskell QuickCheck's Arbitrary1 type class.

Associated Types

type Parameters: Default

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

Loading content...

Required methods

fn lift1_with<AS>(base: AS, args: Self::Parameters) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

Lifts a given Strategy to a new Strategy for the (presumably) bigger type. This is useful for lifting a Strategy for SomeType to a container such as Vec of SomeType. The composite strategy is passed the arguments given in args.

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

Loading content...

Provided methods

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

Lifts a given Strategy to a new Strategy for the (presumably) bigger type. This is useful for lifting a Strategy for SomeType to a container such as Vec<SomeType>.

Calling this for the type X is the equivalent of using X::lift1_with(base, 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<A: Debug + 'static + Copy> ArbitraryF1<A> for Cell<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for RefCell<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for UnsafeCell<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for Reverse<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for Once<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static + Clone> ArbitraryF1<A> for Repeat<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static + Iterator + Clone> ArbitraryF1<A> for Cycle<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static + Iterator> ArbitraryF1<A> for Enumerate<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static + Iterator> ArbitraryF1<A> for Fuse<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static + Iterator<Item = T>, T: Debug> ArbitraryF1<A> for Peekable<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static + DoubleEndedIterator> ArbitraryF1<A> for Rev<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

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

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + Debug + 'static + Iterator, B: 'static + Arbitrary + Iterator> ArbitraryF1<A> for Zip<B, A>

type Parameters = B::Parameters

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

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

type Parameters = B::Parameters

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + Iterator> ArbitraryF1<A> for Skip<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + Iterator> ArbitraryF1<A> for Take<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for Discriminant<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for Wrapping<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug> ArbitraryF1<A> for Option<A>

type Parameters = Probability

fn lift1_with<S>(base: S, prob: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for IntoIter<A>

type Parameters = Probability

fn lift1_with<S>(base: S, prob: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for Result<A, ParseError>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug, E: Arbitrary> ArbitraryF1<A> for Result<A, E> where
    E::Strategy: 'static, 

type Parameters = (Probability, E::Parameters)

fn lift1_with<AS>(base: AS, args: Self::Parameters) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for IntoIter<A>

type Parameters = Probability

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + Borrow<B> + 'static, B: ToOwned<Owned = A> + Debug> ArbitraryF1<A> for Cow<'static, B>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for Box<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug> ArbitraryF1<A> for Vec<A>

type Parameters = SizeRange

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug> ArbitraryF1<A> for VecDeque<A>

type Parameters = SizeRange

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug> ArbitraryF1<A> for LinkedList<A>

type Parameters = SizeRange

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + Ord> ArbitraryF1<A> for BTreeSet<A>

type Parameters = SizeRange

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + Ord> ArbitraryF1<A> for BinaryHeap<A>

type Parameters = SizeRange

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + Hash + Eq> ArbitraryF1<A> for HashSet<A>

type Parameters = SizeRange

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for IntoIter<A>

type Parameters = SizeRange

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for IntoIter<A>

type Parameters = SizeRange

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for IntoIter<A>

type Parameters = SizeRange

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static + Ord> ArbitraryF1<A> for IntoIter<A>

type Parameters = SizeRange

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static + Ord> ArbitraryF1<A> for IntoIter<A>

type Parameters = SizeRange

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static + Hash + Eq> ArbitraryF1<A> for IntoIter<A>

type Parameters = SizeRange

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug, K: Hash + Eq + Arbitrary + 'static> ArbitraryF1<A> for HashMap<K, A>

type Parameters = (SizeRange, K::Parameters)

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static, K: Hash + Eq + Arbitrary + 'static> ArbitraryF1<A> for IntoIter<K, A>

type Parameters = (SizeRange, K::Parameters)

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug, K: Ord + Arbitrary + 'static> ArbitraryF1<A> for BTreeMap<K, A>

type Parameters = (SizeRange, K::Parameters)

fn lift1_with<S>(base: S, args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for Bound<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for RangeFrom<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for RangeTo<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for RangeToInclusive<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + PartialOrd> ArbitraryF1<A> for RangeInclusive<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + PartialOrd> ArbitraryF1<A> for Range<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for Rc<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for Arc<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + Read> ArbitraryF1<A> for BufReader<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + Write> ArbitraryF1<A> for BufWriter<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + Write> ArbitraryF1<A> for LineWriter<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for Cursor<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static + BufRead> ArbitraryF1<A> for Lines<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static + BufRead> ArbitraryF1<A> for Split<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static + Read> ArbitraryF1<A> for Take<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for AssertUnwindSafe<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for Mutex<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

impl<A: Debug + 'static> ArbitraryF1<A> for RwLock<A>

type Parameters = ()

fn lift1_with<S>(base: S, _args: Self::Parameters) -> BoxedStrategy<Self> where
    S: Strategy<Value = A> + 'static, 

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

Loading content...

Implementors

Loading content...