proptest-arbitrary 0.2.0

The Arbitrary trait for proptest and implementations for the standard library. 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

//==============================================================================
// Macros for quick implementing:
//==============================================================================

macro_rules! valuetree {
    () => {
        type ValueTree =
            <Self::Strategy as $crate::proptest::strategy::Strategy>::Value;
    };
}

macro_rules! arbitrary_for {
    ([$($bound : tt)*] $typ: ty, $strat: ty, $params: ty,
        $args: ident => $logic: expr) => {
        impl<'a, $($bound)*> $crate::Arbitrary<'a> for $typ {
            valuetree!();
            type Parameters = $params;
            type Strategy = $strat;
            fn arbitrary_with($args: Self::Parameters) -> Self::Strategy {
                $logic
            }
        }
    };
}

macro_rules! impl_arbitrary {
    ($self: ty, $st: ty, $logic: expr) => {
        arbitrary_for!([] $self, $st, (), _args => $logic);
    };
}

macro_rules! impl_just {
    ($self: ty, $logic: expr) => {
        impl_arbitrary!($self,
            $crate::proptest::strategy::Just<Self>,
            $crate::proptest::strategy::Just($logic));
    };
}

macro_rules! impls {
    ($($self: ident),*) => {
        $(impl_arbitrary!($self, $self::Any, $self::ANY);)*
    };
}

macro_rules! impl_wrap_gen {
    ([$($bound : tt)*] $wrap: ident) => {
        impl_wrap_gen!([$($bound)*] $wrap, $wrap::new);
    };
    ([$($bound : tt)*] $wrap: ident, $maker: expr) => {
        arbitrary_for!([A: $crate::Arbitrary<'a> + $($bound)*] $wrap<A>,
            $crate::SMapped<'a, A, Self>, A::Parameters,
            args => $crate::any_with_smap(args, $maker));
    };
}

macro_rules! impl_wrap_from {
    ([$($bound : tt)*] $wrap: ident) => {
        arbitrary_for!([A: $crate::Arbitrary<'a> + $($bound)*] $wrap<A>,
            $crate::FMapped<'a, A, Self>, A::Parameters,
            args => $crate::any_with_sinto::<A, $wrap<A>>(args));
    };
}

macro_rules! gen_strat {
    ($($self: ty, $fun: expr);+) => {
        $(
            impl_arbitrary!($self,
                $crate::GenStrategy<Self>, $crate::GenStrategy::new($fun));
        )+
    };
}