[][src]Trait bolero_engine::ValueGenerator

pub trait ValueGenerator {
    type Output;
    fn generate<D>(&self, driver: &mut D) -> Option<Self::Output>
    where
        D: Driver
; fn mutate<D>(&self, driver: &mut D, value: &mut Self::Output) -> Option<()>
    where
        D: Driver
, { ... }
fn map<F, T>(self, map: F) -> MapGenerator<Self, F>
    where
        F: Fn(Self::Output) -> T
, { ... }
fn map_gen<F, T>(self, map: F) -> MapGenerator<Self, F>
    where
        F: Fn(Self::Output) -> T
, { ... }
fn and_then<F, T>(self, and_then: F) -> AndThenGenerator<Self, F>
    where
        F: Fn(Self::Output) -> T,
        T: ValueGenerator
, { ... }
fn and_then_gen<F, T>(self, and_then: F) -> AndThenGenerator<Self, F>
    where
        F: Fn(Self::Output) -> T,
        T: ValueGenerator
, { ... }
fn filter<F>(self, filter: F) -> FilterGenerator<Self, F>
    where
        F: Fn(&Self::Output) -> bool
, { ... }
fn filter_gen<F>(self, filter: F) -> FilterGenerator<Self, F>
    where
        F: Fn(&Self::Output) -> bool
, { ... }
fn filter_map<F, T>(self, filter_map: F) -> FilterMapGenerator<Self, F>
    where
        F: Fn(Self::Output) -> Option<T>
, { ... }
fn filter_map_gen<F, T>(self, filter_map: F) -> FilterMapGenerator<Self, F>
    where
        F: Fn(Self::Output) -> Option<T>
, { ... } }

Generate a value with a parameterized generator

Associated Types

type Output

Loading content...

Required methods

fn generate<D>(&self, driver: &mut D) -> Option<Self::Output> where
    D: Driver

Generates a value with the given driver

Loading content...

Provided methods

fn mutate<D>(&self, driver: &mut D, value: &mut Self::Output) -> Option<()> where
    D: Driver

Mutates an existing value with the given driver

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

Map the value of a generator

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

Map the value of a generator, exists to reduce conflicts with other map functions.

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

Map the value of a generator with a new generator

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

Map the value of a generator with a new generator, exists to reduce conflicts with other map functions.

fn filter<F>(self, filter: F) -> FilterGenerator<Self, F> where
    F: Fn(&Self::Output) -> bool

Filter the value of a generator

fn filter_gen<F>(self, filter: F) -> FilterGenerator<Self, F> where
    F: Fn(&Self::Output) -> bool

Filter the value of a generator, exists to reduce conflicts with other filter functions.

fn filter_map<F, T>(self, filter_map: F) -> FilterMapGenerator<Self, F> where
    F: Fn(Self::Output) -> Option<T>, 

Filter the value of a generator and map it to something else

fn filter_map_gen<F, T>(self, filter_map: F) -> FilterMapGenerator<Self, F> where
    F: Fn(Self::Output) -> Option<T>, 

Filter the value of a generator and map it to something else, exists to reduce conflicts with other filter_map functions.

Loading content...

Implementations on Foreign Types

impl<O, A, B, C, D, E, F, G, H, I, J, K, L, M, N> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    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
[src]

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

impl<A> ValueGenerator for (A,) where
    A: ValueGenerator
[src]

type Output = (<A as ValueGenerator>::Output,)

impl ValueGenerator for u16[src]

type Output = u16

impl<V, K> ValueGenerator for HashMap<K, V, RandomState> where
    K: ValueGenerator,
    V: ValueGenerator,
    <K as ValueGenerator>::Output: Sized,
    <K as ValueGenerator>::Output: Hash,
    <K as ValueGenerator>::Output: Eq
[src]

type Output = HashMap<<K as ValueGenerator>::Output, <V as ValueGenerator>::Output, RandomState>

impl<V> ValueGenerator for Vec<V> where
    V: ValueGenerator
[src]

type Output = Vec<<V as ValueGenerator>::Output>

impl<E, A, B, C, D> ValueGenerator for (A, B, C, D, E) where
    A: ValueGenerator,
    B: ValueGenerator,
    C: ValueGenerator,
    D: ValueGenerator,
    E: ValueGenerator
[src]

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output)

impl<G> ValueGenerator for [G; 5] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 5]

impl<K, V, L, Len> ValueGenerator for BTreeMapGenerator<K, V, L> where
    K: ValueGenerator,
    L: ValueGenerator<Output = Len>,
    Len: Into<usize>,
    V: ValueGenerator,
    <K as ValueGenerator>::Output: Sized,
    <K as ValueGenerator>::Output: Ord
[src]

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

impl<G> ValueGenerator for [G; 16] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 16]

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

type Output = Range<T>

impl<G> ValueGenerator for [G; 7] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 7]

impl<P, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    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
[src]

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

impl<O> ValueGenerator for OneValueOf<O> where
    O: OneValueOfGenerator
[src]

type Output = <O as OneValueOfGenerator>::Output

impl ValueGenerator for f32[src]

type Output = f32

impl<G> ValueGenerator for [G; 31] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 31]

impl<V, L, Len> ValueGenerator for VecDequeGenerator<V, L> where
    L: ValueGenerator<Output = Len>,
    Len: Into<usize>,
    V: ValueGenerator
[src]

type Output = VecDeque<<V as ValueGenerator>::Output>

impl<G, F> ValueGenerator for FilterGenerator<G, F> where
    F: Fn(&<G as ValueGenerator>::Output) -> bool,
    G: ValueGenerator
[src]

type Output = <G as ValueGenerator>::Output

impl<T, G, B> ValueGenerator for BoundedGenerator<G, B> where
    B: RangeBounds<<T as BoundedValue<B>>::BoundValue>,
    G: ValueGenerator<Output = T>,
    T: BoundedValue<B>, 
[src]

type Output = T

impl ValueGenerator for char[src]

type Output = char

impl<V, L, Len> ValueGenerator for BTreeSetGenerator<V, L> where
    L: ValueGenerator<Output = Len>,
    Len: Into<usize>,
    V: ValueGenerator,
    <V as ValueGenerator>::Output: Sized,
    <V as ValueGenerator>::Output: Ord
[src]

type Output = BTreeSet<<V as ValueGenerator>::Output>

impl<V> ValueGenerator for VecDeque<V> where
    V: ValueGenerator
[src]

type Output = VecDeque<<V as ValueGenerator>::Output>

impl<G> ValueGenerator for [G; 14] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 14]

impl<G> ValueGenerator for [G; 1] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 1]

impl<V, L, Len> ValueGenerator for LinkedListGenerator<V, L> where
    L: ValueGenerator<Output = Len>,
    Len: Into<usize>,
    V: ValueGenerator
[src]

type Output = LinkedList<<V as ValueGenerator>::Output>

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    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
[src]

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

impl<T> ValueGenerator for RangeFrom<T> where
    T: BoundedValue<RangeFrom<T>> + TypeGenerator
[src]

type Output = T

impl<G> ValueGenerator for [G; 24] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 24]

impl ValueGenerator for usize[src]

type Output = usize

impl ValueGenerator for String[src]

type Output = String

impl<T> ValueGenerator for RangeToInclusive<T> where
    T: BoundedValue<RangeToInclusive<T>> + TypeGenerator
[src]

type Output = T

impl<T> ValueGenerator for TypeValueGenerator<T> where
    T: TypeGenerator
[src]

type Output = T

impl<G> ValueGenerator for [G; 33] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 33]

impl ValueGenerator for u64[src]

type Output = u64

impl<M, A, B, C, D, E, F, G, H, I, J, K, L> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    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
[src]

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

impl ValueGenerator for f64[src]

type Output = f64

impl<G> ValueGenerator for [G; 29] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 29]

impl<G> ValueGenerator for [G; 25] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 25]

impl<T> ValueGenerator for Constant<T> where
    T: Clone
[src]

type Output = T

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

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

impl<V, L, Len> ValueGenerator for HashSetGenerator<V, L> where
    L: ValueGenerator<Output = Len>,
    Len: Into<usize>,
    V: ValueGenerator,
    <V as ValueGenerator>::Output: Sized,
    <V as ValueGenerator>::Output: Hash,
    <V as ValueGenerator>::Output: Eq
[src]

type Output = HashSet<<V as ValueGenerator>::Output, RandomState>

impl<G> ValueGenerator for [G; 20] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 20]

impl<V, K> ValueGenerator for BTreeMap<K, V> where
    K: ValueGenerator,
    V: ValueGenerator,
    <K as ValueGenerator>::Output: Sized,
    <K as ValueGenerator>::Output: Ord
[src]

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

impl<'a, T> ValueGenerator for &'a T where
    T: ValueGenerator
[src]

type Output = <T as ValueGenerator>::Output

impl<G> ValueGenerator for [G; 26] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 26]

impl<AF, 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, AA, AB, AC, AD, AE> 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, AA, AB, AC, AD, AE, AF) where
    A: ValueGenerator,
    AA: ValueGenerator,
    AB: ValueGenerator,
    AC: ValueGenerator,
    AD: ValueGenerator,
    AE: ValueGenerator,
    AF: 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,
    Z: ValueGenerator
[src]

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output, <AA as ValueGenerator>::Output, <AB as ValueGenerator>::Output, <AC as ValueGenerator>::Output, <AD as ValueGenerator>::Output, <AE as ValueGenerator>::Output, <AF as ValueGenerator>::Output)

impl<AA, 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> 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, AA) where
    A: ValueGenerator,
    AA: 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,
    Z: ValueGenerator
[src]

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

impl<O> ValueGenerator for OneOf<O> where
    O: OneOfGenerator
[src]

type Output = <O as OneOfGenerator>::Output

impl<G> ValueGenerator for [G; 21] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 21]

impl<Left, Right, Selector> ValueGenerator for EitherGenerator<Left, Right, Selector> where
    Left: ValueGenerator,
    Right: ValueGenerator,
    Selector: ValueGenerator<Output = bool>, 
[src]

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

impl<G> ValueGenerator for [G; 10] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 10]

impl<V> ValueGenerator for BinaryHeap<V> where
    V: ValueGenerator,
    <V as ValueGenerator>::Output: Sized,
    <V as ValueGenerator>::Output: Ord
[src]

type Output = BinaryHeap<<V as ValueGenerator>::Output>

impl<Y, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> 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) where
    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
[src]

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

impl<S, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) where
    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
[src]

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

impl ValueGenerator for i16[src]

type Output = i16

impl<D, A, B, C> ValueGenerator for (A, B, C, D) where
    A: ValueGenerator,
    B: ValueGenerator,
    C: ValueGenerator,
    D: ValueGenerator
[src]

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output)

impl<G> ValueGenerator for [G; 30] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 30]

impl<G, F, T> ValueGenerator for FilterMapGenerator<G, F> where
    F: Fn(<G as ValueGenerator>::Output) -> Option<T>,
    G: ValueGenerator
[src]

type Output = T

impl ValueGenerator for u128[src]

type Output = u128

impl ValueGenerator for i64[src]

type Output = i64

impl<AD, 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, AA, AB, AC> 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, AA, AB, AC, AD) where
    A: ValueGenerator,
    AA: ValueGenerator,
    AB: ValueGenerator,
    AC: ValueGenerator,
    AD: 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,
    Z: ValueGenerator
[src]

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

impl<AC, 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, AA, AB> 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, AA, AB, AC) where
    A: ValueGenerator,
    AA: ValueGenerator,
    AB: ValueGenerator,
    AC: 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,
    Z: ValueGenerator
[src]

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

impl<X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> 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) where
    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
[src]

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

impl<AE, 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, AA, AB, AC, AD> 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, AA, AB, AC, AD, AE) where
    A: ValueGenerator,
    AA: ValueGenerator,
    AB: ValueGenerator,
    AC: ValueGenerator,
    AD: ValueGenerator,
    AE: 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,
    Z: ValueGenerator
[src]

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output, <AA as ValueGenerator>::Output, <AB as ValueGenerator>::Output, <AC as ValueGenerator>::Output, <AD as ValueGenerator>::Output, <AE as ValueGenerator>::Output)

impl ValueGenerator for i32[src]

type Output = i32

impl<V, L, Len> ValueGenerator for VecGenerator<V, L> where
    L: ValueGenerator<Output = Len>,
    Len: Into<usize>,
    V: ValueGenerator
[src]

type Output = Vec<<V as ValueGenerator>::Output>

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

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

impl<R, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where
    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
[src]

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

impl<G> ValueGenerator for [G; 2] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 2]

impl<W, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> 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) where
    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
[src]

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

impl<G> ValueGenerator for [G; 3] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 3]

impl<Ok, Err, Selector> ValueGenerator for ResultGenerator<Ok, Err, Selector> where
    Err: ValueGenerator,
    Ok: ValueGenerator,
    Selector: ValueGenerator<Output = bool>, 
[src]

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

impl<U, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) where
    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
[src]

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

impl<T> ValueGenerator for PhantomData<T>[src]

type Output = PhantomData<T>

impl ValueGenerator for u32[src]

type Output = u32

impl<V, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) where
    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
[src]

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

impl<G> ValueGenerator for [G; 8] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 8]

impl<T> ValueGenerator for [T; 0][src]

type Output = [T; 0]

impl<G> ValueGenerator for [G; 11] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 11]

impl<G> ValueGenerator for [G; 4] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 4]

impl<G> ValueGenerator for [G; 12] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 12]

impl<B, A> ValueGenerator for (A, B) where
    A: ValueGenerator,
    B: ValueGenerator
[src]

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output)

impl ValueGenerator for u8[src]

type Output = u8

impl<G> ValueGenerator for [G; 28] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 28]

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

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output)

impl ValueGenerator for ()[src]

type Output = ()

impl<G> ValueGenerator for [G; 6] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 6]

impl<T> ValueGenerator for Range<T> where
    T: BoundedValue<Range<T>> + TypeGenerator
[src]

type Output = T

impl<G> ValueGenerator for [G; 22] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 22]

impl<G, H, F> ValueGenerator for AndThenGenerator<G, F> where
    F: Fn(<G as ValueGenerator>::Output) -> H,
    G: ValueGenerator,
    H: ValueGenerator
[src]

type Output = <H as ValueGenerator>::Output

impl<G> ValueGenerator for [G; 27] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 27]

impl<G, L, Len> ValueGenerator for StringGenerator<G, L> where
    G: ValueGenerator<Output = char>,
    L: ValueGenerator<Output = Len>,
    Len: Into<usize>, 
[src]

type Output = String

impl<Q, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    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
[src]

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

impl<V, L, Len> ValueGenerator for BinaryHeapGenerator<V, L> where
    L: ValueGenerator<Output = Len>,
    Len: Into<usize>,
    V: ValueGenerator,
    <V as ValueGenerator>::Output: Sized,
    <V as ValueGenerator>::Output: Ord
[src]

type Output = BinaryHeap<<V as ValueGenerator>::Output>

impl<G> ValueGenerator for [G; 19] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 19]

impl<AB, 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, AA> 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, AA, AB) where
    A: ValueGenerator,
    AA: ValueGenerator,
    AB: 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,
    Z: ValueGenerator
[src]

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

impl ValueGenerator for isize[src]

type Output = isize

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

type Output = RangeInclusive<T>

impl<V> ValueGenerator for BTreeSet<V> where
    V: ValueGenerator,
    <V as ValueGenerator>::Output: Sized,
    <V as ValueGenerator>::Output: Ord
[src]

type Output = BTreeSet<<V as ValueGenerator>::Output>

impl<G> ValueGenerator for [G; 18] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 18]

impl<G> ValueGenerator for [G; 15] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 15]

impl ValueGenerator for bool[src]

type Output = bool

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

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

impl<T> ValueGenerator for RangeInclusive<T> where
    T: BoundedValue<RangeInclusive<T>> + TypeGenerator
[src]

type Output = T

impl<G> ValueGenerator for [G; 32] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 32]

impl<K, V, L, Len> ValueGenerator for HashMapGenerator<K, V, L> where
    K: ValueGenerator,
    L: ValueGenerator<Output = Len>,
    Len: Into<usize>,
    V: ValueGenerator,
    <K as ValueGenerator>::Output: Sized,
    <K as ValueGenerator>::Output: Hash,
    <K as ValueGenerator>::Output: Eq
[src]

type Output = HashMap<<K as ValueGenerator>::Output, <V as ValueGenerator>::Output, RandomState>

impl<V> ValueGenerator for HashSet<V, RandomState> where
    V: ValueGenerator,
    <V as ValueGenerator>::Output: Sized,
    <V as ValueGenerator>::Output: Hash,
    <V as ValueGenerator>::Output: Eq
[src]

type Output = HashSet<<V as ValueGenerator>::Output, RandomState>

impl<G> ValueGenerator for [G; 13] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 13]

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

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output)

impl<V> ValueGenerator for LinkedList<V> where
    V: ValueGenerator
[src]

type Output = LinkedList<<V as ValueGenerator>::Output>

impl ValueGenerator for i128[src]

type Output = i128

impl<G, M, T> ValueGenerator for MapGenerator<G, M> where
    G: ValueGenerator,
    M: Fn(<G as ValueGenerator>::Output) -> T, 
[src]

type Output = T

impl ValueGenerator for i8[src]

type Output = i8

impl<V, Selector> ValueGenerator for OptionGenerator<V, Selector> where
    Selector: ValueGenerator<Output = bool>,
    V: ValueGenerator
[src]

type Output = Option<<V as ValueGenerator>::Output>

impl<AG, 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, AA, AB, AC, AD, AE, AF> 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, AA, AB, AC, AD, AE, AF, AG) where
    A: ValueGenerator,
    AA: ValueGenerator,
    AB: ValueGenerator,
    AC: ValueGenerator,
    AD: ValueGenerator,
    AE: ValueGenerator,
    AF: ValueGenerator,
    AG: 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,
    Z: ValueGenerator
[src]

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output, <AA as ValueGenerator>::Output, <AB as ValueGenerator>::Output, <AC as ValueGenerator>::Output, <AD as ValueGenerator>::Output, <AE as ValueGenerator>::Output, <AF as ValueGenerator>::Output, <AG as ValueGenerator>::Output)

impl<G> ValueGenerator for [G; 9] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 9]

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

type Output = Duration

impl ValueGenerator for BooleanGenerator[src]

type Output = bool

impl<T> ValueGenerator for RangeTo<T> where
    T: BoundedValue<RangeTo<T>> + TypeGenerator
[src]

type Output = T

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

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

impl<G> ValueGenerator for [G; 23] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 23]

impl<C, A, B> ValueGenerator for (A, B, C) where
    A: ValueGenerator,
    B: ValueGenerator,
    C: ValueGenerator
[src]

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output)

impl<Z, 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> 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) where
    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,
    Z: ValueGenerator
[src]

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

impl<F, A, B, C, D, E> ValueGenerator for (A, B, C, D, E, F) where
    A: ValueGenerator,
    B: ValueGenerator,
    C: ValueGenerator,
    D: ValueGenerator,
    E: ValueGenerator,
    F: ValueGenerator
[src]

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output)

impl<G> ValueGenerator for [G; 17] where
    G: ValueGenerator
[src]

type Output = [<G as ValueGenerator>::Output; 17]

impl<N, A, B, C, D, E, F, G, H, I, J, K, L, M> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    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
[src]

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

Loading content...

Implementors

Loading content...