Trait bolero_generator::ValueGenerator

pub trait ValueGenerator: Sized {
    type Output;
    fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output;

    fn map<F: Fn(Self::Output) -> T, T>(self, map: F) -> MapGenerator<Self, F> { ... }
    fn and_then<F: Fn(Self::Output) -> T, T: ValueGenerator>(
        self, 
        and_then: F
    ) -> AndThenGenerator<Self, F> { ... }
}

Generate a value with a parameterized generator

Associated Types

type Output

Loading content...

Required methods

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

Loading content...

Provided methods

fn map<F: Fn(Self::Output) -> T, T>(self, map: F) -> MapGenerator<Self, F>

fn and_then<F: Fn(Self::Output) -> T, T: ValueGenerator>(
    self,
    and_then: F
) -> AndThenGenerator<Self, F>

Loading content...

Implementations on Foreign Types

impl ValueGenerator for String

type Output = Self

fn generate<R: Rng>(&self, _rng: &mut R) -> Self

impl ValueGenerator for bool

type Output = bool

fn generate<R: Rng>(&self, _rng: &mut R) -> Self::Output

impl<T: TypeGenerator + BoundedValue> ValueGenerator for Range<T>

type Output = T

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<T: TypeGenerator + BoundedValue> ValueGenerator for RangeFrom<T>

type Output = T

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<T: TypeGenerator + BoundedValue> ValueGenerator for RangeInclusive<T>

type Output = T

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<T: TypeGenerator + BoundedValue> ValueGenerator for RangeTo<T>

type Output = T

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<T: TypeGenerator + BoundedValue> ValueGenerator for RangeToInclusive<T>

type Output = T

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl ValueGenerator for char

type Output = char

fn generate<R: Rng>(&self, _rng: &mut R) -> Self

impl ValueGenerator for u8

type Output = u8

fn generate<R: Rng>(&self, _rng: &mut R) -> Self

impl ValueGenerator for i8

type Output = i8

fn generate<R: Rng>(&self, _rng: &mut R) -> Self

impl ValueGenerator for u16

type Output = u16

fn generate<R: Rng>(&self, _rng: &mut R) -> Self

impl ValueGenerator for i16

type Output = i16

fn generate<R: Rng>(&self, _rng: &mut R) -> Self

impl ValueGenerator for u32

type Output = u32

fn generate<R: Rng>(&self, _rng: &mut R) -> Self

impl ValueGenerator for i32

type Output = i32

fn generate<R: Rng>(&self, _rng: &mut R) -> Self

impl ValueGenerator for u64

type Output = u64

fn generate<R: Rng>(&self, _rng: &mut R) -> Self

impl ValueGenerator for i64

type Output = i64

fn generate<R: Rng>(&self, _rng: &mut R) -> Self

impl ValueGenerator for u128

type Output = u128

fn generate<R: Rng>(&self, _rng: &mut R) -> Self

impl ValueGenerator for i128

type Output = i128

fn generate<R: Rng>(&self, _rng: &mut R) -> Self

impl ValueGenerator for usize

type Output = usize

fn generate<R: Rng>(&self, _rng: &mut R) -> Self

impl ValueGenerator for isize

type Output = isize

fn generate<R: Rng>(&self, _rng: &mut R) -> Self

impl ValueGenerator for f32

type Output = f32

fn generate<R: Rng>(&self, _rng: &mut R) -> Self

impl ValueGenerator for f64

type Output = f64

fn generate<R: Rng>(&self, _rng: &mut R) -> Self

impl<A: ValueGenerator> ValueGenerator for (A,)

type Output = (A::Output,)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<B: ValueGenerator, A: ValueGenerator> ValueGenerator for (A, B)

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

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<C: ValueGenerator, A: ValueGenerator, B: ValueGenerator> ValueGenerator for (A, B, C)

type Output = (A::Output, B::Output, C::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<D: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator> ValueGenerator for (A, B, C, D)

type Output = (A::Output, B::Output, C::Output, D::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<E: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator> ValueGenerator for (A, B, C, D, E)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<F: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator> ValueGenerator for (A, B, C, D, E, F)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<G: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<H: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<I: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<J: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<K: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<L: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<M: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<N: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<O: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, O::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<P: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, O::Output, P::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<Q: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, O::Output, P::Output, Q::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<R: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, O::Output, P::Output, Q::Output, R::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<S: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, O::Output, P::Output, Q::Output, R::Output, S::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<T: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, O::Output, P::Output, Q::Output, R::Output, S::Output, T::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<U: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, O::Output, P::Output, Q::Output, R::Output, S::Output, T::Output, U::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<V: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, O::Output, P::Output, Q::Output, R::Output, S::Output, T::Output, U::Output, V::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<W: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, O::Output, P::Output, Q::Output, R::Output, S::Output, T::Output, U::Output, V::Output, W::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<X: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, O::Output, P::Output, Q::Output, R::Output, S::Output, T::Output, U::Output, V::Output, W::Output, X::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<Y: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, O::Output, P::Output, Q::Output, R::Output, S::Output, T::Output, U::Output, V::Output, W::Output, X::Output, Y::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl<Z: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator, Y: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output, N::Output, O::Output, P::Output, Q::Output, R::Output, S::Output, T::Output, U::Output, V::Output, W::Output, X::Output, Y::Output, Z::Output)

fn generate<R_: Rng>(&self, rng: &mut R_) -> Self::Output

impl ValueGenerator for ()

type Output = ()

fn generate<R: Rng>(&self, _rng: &mut R) -> Self

impl<T> ValueGenerator for PhantomData<T>

type Output = Self

fn generate<R: Rng>(&self, _rng: &mut R) -> Self::Output

Loading content...

Implementors

impl ValueGenerator for BooleanGenerator

type Output = bool

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<G: ValueGenerator, H: ValueGenerator, F: Fn(G::Output) -> H> ValueGenerator for AndThenGenerator<G, F>

type Output = H::Output

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<G: ValueGenerator, M: Fn(G::Output) -> T, T> ValueGenerator for MapGenerator<G, M>

type Output = T

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<K: ValueGenerator, V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for BTreeMapGenerator<K, V, L> where
    K::Output: Sized + Ord, 

type Output = BTreeMap<K::Output, V::Output>

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for StringGenerator<L>

type Output = String

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<Left: ValueGenerator, Right: ValueGenerator, Selector: ValueGenerator<Output = bool>> ValueGenerator for EitherGenerator<Left, Right, Selector>

type Output = Either<Left::Output, Right::Output>

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<Ok: ValueGenerator, Err: ValueGenerator, Selector: ValueGenerator<Output = bool>> ValueGenerator for ResultGenerator<Ok, Err, Selector>

type Output = Result<Ok::Output, Err::Output>

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<Seconds, Nanos> ValueGenerator for DurationGenerator<Seconds, Nanos> where
    Seconds: ValueGenerator<Output = u64>,
    Nanos: ValueGenerator<Output = u32>, 

type Output = Duration

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<Start, End, T> ValueGenerator for RangeGenerator<Start, End> where
    Start: ValueGenerator<Output = T>,
    End: ValueGenerator<Output = T>, 

type Output = Range<T>

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<Start, End, T> ValueGenerator for RangeInclusiveGenerator<Start, End> where
    Start: ValueGenerator<Output = T>,
    End: ValueGenerator<Output = T>, 

type Output = RangeInclusive<T>

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<T: BoundedValue, G: ValueGenerator<Output = T>> ValueGenerator for BoundedGenerator<G, T>

type Output = T

fn generate<R: Rng>(&self, rng: &mut R) -> T

impl<T: TypeGenerator> ValueGenerator for TypeValueGenerator<T>

type Output = T

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<T: Clone> ValueGenerator for Constant<T>

type Output = T

fn generate<R: Rng>(&self, _rng: &mut R) -> Self::Output

impl<V: ValueGenerator> ValueGenerator for BTreeSet<V> where
    V::Output: Sized + Ord, 

type Output = BTreeSet<V::Output>

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<V: ValueGenerator> ValueGenerator for BinaryHeap<V> where
    V::Output: Sized + Ord, 

type Output = BinaryHeap<V::Output>

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<V: ValueGenerator> ValueGenerator for LinkedList<V>

type Output = LinkedList<V::Output>

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<V: ValueGenerator> ValueGenerator for Vec<V>

type Output = Vec<V::Output>

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<V: ValueGenerator> ValueGenerator for VecDeque<V>

type Output = VecDeque<V::Output>

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<V: ValueGenerator, K: ValueGenerator> ValueGenerator for BTreeMap<K, V> where
    K::Output: Sized + Ord, 

type Output = BTreeMap<K::Output, V::Output>

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for BTreeSetGenerator<V, L> where
    V::Output: Sized + Ord, 

type Output = BTreeSet<V::Output>

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for BinaryHeapGenerator<V, L> where
    V::Output: Sized + Ord, 

type Output = BinaryHeap<V::Output>

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for LinkedListGenerator<V, L>

type Output = LinkedList<V::Output>

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for VecDequeGenerator<V, L>

type Output = VecDeque<V::Output>

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for VecGenerator<V, L>

type Output = Vec<V::Output>

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

impl<V: ValueGenerator, Selector: ValueGenerator<Output = bool>> ValueGenerator for OptionGenerator<V, Selector>

type Output = Option<V::Output>

fn generate<R: Rng>(&self, rng: &mut R) -> Self::Output

Loading content...