pergola 0.9.0

abstract types for join-semilattices
Documentation 
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

// Copyright 2020 Graydon Hoare <graydon@pobox.com>
// Licensed under the MIT and Apache-2.0 licenses.

use super::*;
use quickcheck::{quickcheck, Arbitrary, Gen};
use std::cmp::Ordering;
use std::fmt::Debug;

// Quickcheck stuff
//
// This is broadly less-effective than the proptest stuff because many
// of the sparse lattices (maps, sets) just produce unordered elts. But it's
// cheap to test, and some of the tests are meaningful, so why not?

fn join_assoc<D: LatticeDef>(a: LatticeElt<D>, b: LatticeElt<D>, c: LatticeElt<D>) -> bool
where
    D: Debug,
    D::T: Debug,
{
    println!(
        "\tjoin associativity lhs: {:?} + ({:?} + {:?}) == {:?}",
        a.value,
        b.value,
        c.value,
        (&a + (&b + &c)).value
    );
    println!(
        "\tjoin associativity rhs: ({:?} + {:?}) + {:?} == {:?}",
        a.value,
        b.value,
        c.value,
        ((&a + &b) + &c).value
    );
    (&a + (&b + &c)) == ((&a + &b) + &c)
}

fn join_comm<D: LatticeDef>(a: LatticeElt<D>, b: LatticeElt<D>) -> bool
where
    D: Debug,
    D::T: Debug,
{
    println!(
        "\tjoin commutativity lhs: {:?} + {:?} == {:?}",
        a.value,
        b.value,
        (&a + &b).value
    );
    println!(
        "\tjoin commutativity rhs: {:?} + {:?} == {:?}",
        b.value,
        a.value,
        (&b + &a).value
    );
    (&a + &b) == (&b + &a)
}

fn join_idem<D: LatticeDef>(a: LatticeElt<D>) -> bool
where
    D: Debug,
    D::T: Debug,
{
    println!(
        "\tjoin idempotence: {:?} + {:?} == {:?}",
        a.value,
        a.value,
        (&a + &a).value
    );
    (&a + &a) == a
}

fn join_unit<D: LatticeDef>(a: LatticeElt<D>) -> bool
where
    D: Debug,
    D::T: Debug,
{
    println!(
        "\tjoin unit: {:?} + {:?} == {:?}",
        a.value,
        &LatticeElt::<D>::default(),
        (&a + &LatticeElt::<D>::default())
    );
    (&a + &LatticeElt::<D>::default()) == a
}

fn join_order<D: LatticeDef>(a: LatticeElt<D>, b: LatticeElt<D>) -> bool
where
    D: Debug,
    D::T: Debug,
{
    match a.partial_cmp(&b) {
        None => {
            println!("\tjoin order: {:?} unordered wrt. {:?}", a.value, b.value);
            true
        }
        Some(Ordering::Equal) => {
            println!(
                "\tjoin order: {:?} == {:?} ==> {:?} + {:?} == {:?} == {:?}",
                a.value, b.value, a.value, b.value, a.value, b.value
            );
            (&a + &b) == b && (&a + &b) == a
        }
        Some(Ordering::Less) => {
            println!(
                "\tjoin order: {:?} < {:?} ==> {:?} + {:?} == {:?}",
                a.value, b.value, a.value, b.value, b.value
            );
            (&a + &b) == b
        }
        Some(Ordering::Greater) => {
            println!(
                "\tjoin order: {:?} > {:?} ==> {:?} + {:?} == {:?}",
                a.value, b.value, a.value, b.value, a.value
            );
            (&a + &b) == a
        }
    }
}

impl<D: LatticeDef> Arbitrary for LatticeElt<D>
where
    D: 'static,
    D::T: Arbitrary,
{
    fn arbitrary<G: Gen>(g: &mut G) -> LatticeElt<D> {
        LatticeElt::new_from(D::T::arbitrary(g))
    }
}

fn quickcheck_props<D: LatticeDef>()
where
    LatticeElt<D>: Arbitrary,
    D: Debug,
    D::T: Debug,
{
    quickcheck(join_assoc as fn(LatticeElt<D>, LatticeElt<D>, LatticeElt<D>) -> bool);
    quickcheck(join_idem as fn(LatticeElt<D>) -> bool);
    quickcheck(join_unit as fn(LatticeElt<D>) -> bool);
    quickcheck(join_comm as fn(LatticeElt<D>, LatticeElt<D>) -> bool);
    quickcheck(join_order as fn(LatticeElt<D>, LatticeElt<D>) -> bool);
}

#[test]
fn quickcheck_others() {
    quickcheck_props::<MaxDef<u32>>();
    quickcheck_props::<MaxDef<String>>();
    quickcheck_props::<MaxNum<i8>>();
    quickcheck_props::<MinNum<i8>>();
    quickcheck_props::<MinNum<u64>>();
    quickcheck_props::<Tuple2<MaxDef<u32>, MaxDef<u32>>>();
    quickcheck_props::<Tuple3<MaxDef<u64>, MaxDef<String>, MinNum<i32>>>();
    quickcheck_props::<BTreeMapWithUnion<u32, MaxDef<u32>>>();
    quickcheck_props::<BTreeMapWithUnion<u32, Tuple2<MinNum<i8>, MaxDef<String>>>>();
    quickcheck_props::<BTreeMapWithIntersection<u32, MaxDef<Vec<u8>>>>();
    quickcheck_props::<Tuple2<BTreeSetWithUnion<String>, BTreeSetWithIntersection<char>>>();
}