canrun_collections 0.1.0

Collection related types and goal constructors for the Canrun crate
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

use super::{unify_entries, LMap};
use canrun::{custom, project_2, DomainType, Goal, IntoVal, UnifyIn};
use std::fmt::Debug;
use std::hash::Hash;

/// Assert that [`LMap`] `a` is a subset of [`LMap`] `b`.
///
/// This means that all of the keys in `a` unify with keys in `b` AND the
/// corresponding values also unify. This is the opposite of [`is_superset`].
///
/// # Example:
/// ```
/// use canrun::{var, Goal};
/// use canrun_collections::lmap::{lmap, is_subset};
/// use canrun_collections::example::Collections;
///
/// let x = var();
/// let goal: Goal<Collections> = is_subset(lmap! {x => 2}, lmap! {1 => 2, 3 => 4});
/// let results: Vec<_> = goal.query(x).collect();
/// assert_eq!(results, vec![1]);
/// ```
pub fn is_subset<'a, K, V, A, B, D>(a: A, b: B) -> Goal<'a, D>
where
    K: Debug + Eq + Hash + UnifyIn<'a, D> + 'a,
    V: Debug + UnifyIn<'a, D> + 'a,
    A: IntoVal<LMap<K, V>>,
    B: IntoVal<LMap<K, V>>,
    D: DomainType<'a, LMap<K, V>> + DomainType<'a, K> + DomainType<'a, V> + 'a,
{
    project_2(a, b, |a, b| {
        custom(move |state| unify_entries(state, a.clone(), b.clone()))
    })
}

/// Assert that [`LMap`] `a` is a superset of [`LMap`] `b`.
///
/// This means that all of the keys in `b` unify with keys in `a` AND the
/// corresponding values also unify. This is the opposite of [`is_subset`].
///
/// # Example:
/// ```
/// use canrun::{var, Goal};
/// use canrun_collections::lmap::{lmap, is_superset};
/// use canrun_collections::example::Collections;
///
/// let x = var();
/// let goal: Goal<Collections> = is_superset(lmap! {x => 2, 3 => 4}, lmap! {1 => 2});
/// let results: Vec<_> = goal.query(x).collect();
/// assert_eq!(results, vec![1]);
/// ```
pub fn is_superset<'a, K, V, A, B, D>(a: A, b: B) -> Goal<'a, D>
where
    K: Debug + Eq + Hash + UnifyIn<'a, D> + 'a,
    V: Debug + UnifyIn<'a, D> + 'a,
    A: IntoVal<LMap<K, V>>,
    B: IntoVal<LMap<K, V>>,
    D: DomainType<'a, LMap<K, V>> + DomainType<'a, K> + DomainType<'a, V> + 'a,
{
    is_subset(b, a)
}

#[cfg(test)]
mod tests {
    use super::{is_subset, is_superset};
    use crate::example::Collections;
    use crate::lmap;
    use canrun::{var, Goal, IterResolved};

    #[test]
    fn is_subset_should_succeed_on() {
        let x = var();
        let cases = vec![
            (lmap! {1 => 2}, lmap! {1 => 2}),
            (lmap! {1 => 2}, lmap! {1 => 2, 3 => 4}),
            (lmap! {x => 2}, lmap! {1 => 2, 3 => 4}),
            (lmap! {x => 2}, lmap! {x => 2, 3 => 4}),
        ];
        for (a, b) in cases {
            let goal: Goal<Collections> = is_subset(&a, &b);
            if goal.iter_resolved().count() != 1 {
                panic!("is_subset failed on {:?} {:?}", a, b);
            }
        }
    }

    #[test]
    fn is_subset_should_fail_on() {
        let x = var();
        let cases = vec![
            (lmap! {1 => 2, 3 => 4}, lmap! {1 => 2}),
            (lmap! {x => 2}, lmap! {1 => 1}),
            (lmap! {x => 2}, lmap! {1 => 2, x => 4}),
        ];
        for (a, b) in cases {
            let goal: Goal<Collections> = is_subset(&a, &b);
            if goal.iter_resolved().count() != 0 {
                panic!("is_subset erroneously succeeded on {:?} {:?}", a, b);
            }
        }
    }

    #[test]
    fn is_superset_should_succeed_on() {
        let x = var();
        let cases = vec![
            (lmap! {1 => 2}, lmap! {1 => 2}),
            (lmap! {1 => 2, 3 => 4}, lmap! {1 => 2}),
            (lmap! {x => 2, 3 => 4}, lmap! {x => 2}),
        ];
        for (a, b) in cases {
            let goal: Goal<Collections> = is_superset(&a, &b);
            if goal.iter_resolved().count() != 1 {
                panic!("is_superset failed on {:?} {:?}", a, b);
            }
        }
    }

    #[test]
    fn is_superset_should_fail_on() {
        let x = var();
        let cases = vec![
            (lmap! {1 => 2}, lmap! {1 => 2, 3 => 4}),
            (lmap! {x => 2}, lmap! {1 => 1}),
            (lmap! {1 => 2, x => 4}, lmap! {x => 2}),
        ];
        for (a, b) in cases {
            let goal: Goal<Collections> = is_superset(&a, &b);
            if goal.iter_resolved().count() != 0 {
                panic!("is_superset erroneously succeeded on {:?} {:?}", a, b);
            }
        }
    }
}